@jinn-network/client 0.1.3-canary.2d6b2676 → 0.1.3-canary.8e61ba74

package/dist/adapters/mech/adapter.js

@@ -1,5 +1,5 @@
-import { getAddress } from 'viem';
-import { keccak256 } from 'viem';
+import { getAddress, zeroAddress } from 'viem';
+import { keccak256, toBytes } from 'viem';
 import { privateKeyToAccount } from 'viem/accounts';
 import { base, baseSepolia } from 'viem/chains';
 import { PermanentError, parseTask } from '../../types/index.js';
@@ -7,13 +7,19 @@ import { createClients } from './safe.js';
 import { buildResultPayload, uploadToIpfs, cidToDigestHex, fetchFromIpfs, fetchSignedTaskFromIpfs, fetchSignedEnvelopeFromIpfs, } from './ipfs.js';
 import { canonicalJson } from '../../harnesses/engine/canonical-json.js';
 import { SignedEnvelopeSchema } from '../../types/envelope.js';
-import { submitTask, submitEvaluationJob, claimDelivery, getMechDeliveryRate, getTimeoutBounds, decodeMarketplaceRequestLogs, decodeDeliverLogs, callDeliverToMarketplace, scanTasks, scanEvaluationJobs, scanLatestRequestDataByRid, scanLatestDeliveryDataByRid, findLatestDeliveryDataHexForRequest, } from './contracts.js';
-import { MECH_MARKETPLACE_ABI } from './types.js';
-import { AcceptAllPolicy } from './claim-policy.js';
+import { submitTask, claimTask as claimTaskOnchain, claimEvaluation as claimEvaluationOnchain, claimDelivery, getMechDeliveryRate, getTimeoutBounds, decodeTaskCreatedLogs, decodeSolutionDeliveryClaimedLogs, decodeDeliverLogs, findLatestDeliveryDataHexForRequest, getMarketplaceRequestDeliveryMech, getTaskCidDigest, callDeliverToMarketplace, } from './contracts.js';
 import { withRecoverableRetry } from '../../tx-retry.js';
 import { formatRpcError } from '../../rpc-error-context.js';
-import { RESTORATION_TASK_CID_CONTEXT_KEY, RESTORATION_ENVELOPE_CID_CONTEXT_KEY } from '../../harnesses/impls/evaluation-context.js';
+import { RESTORATION_ENVELOPE_CID_CONTEXT_KEY, RESTORATION_TASK_CID_CONTEXT_KEY, } from '../../harnesses/impls/evaluation-context.js';
 import { signTaskV1 } from '../../tasks/signing.js';
+const ROUTER_REQUEST_CURSOR_CONFIG_KEY = 'mech_router_request_block_cursor_v1';
+const PENDING_EVALUATION_SOLUTIONS_CONFIG_KEY = 'mech_pending_evaluation_solutions_v1';
+const DEFAULT_MECH_CLAIM_POLICY = {
+    mode: 'exclusive',
+    maxClaims: 1,
+    maxClaimsPerOperator: 1,
+    claimLeaseTtlSeconds: 30 * 60,
+};
 export class MechAdapter {
     name = 'mech';
     publicClient;
@@ -23,27 +29,17 @@ export class MechAdapter {
     requestBlockCursor = 0n;
     deliveryBlockCursor = 0n;
     pendingEvaluations = new Map();
-    pendingEvaluationClaims = new Set();
-    // Restoration requests where claimDelivery succeeded but evaluation creation failed.
-    // Swept on each poll cycle so they don't require a new Deliver event.
-    claimedButNotEvaluated = new Set();
-    // Restoration result content cached across evaluation-job retries so a transient
-    // Safe/router failure does not silently strip evaluator context on the next poll.
-    pendingEvaluationResults = new Map();
-    // IPFS CID of the restoration envelope — threaded into evaluation context so
-    // evaluators can populate restorationEnvelope.cid without a synchronous IPFS fetch.
-    pendingEvaluationResultCids = new Map();
-    // RIDs with no delivery found in backfill window; avoids repeated 500k-block rescans.
-    backfillMissRids = new Set();
+    observedTasks = new Map();
+    requestKinds = new Map();
+    evaluationOpportunities = new Map();
+    pendingEvaluationSolutions = new Map();
     // Original Tasks keyed by request ID (restoration and evaluation)
     // so we can yield accurate Task in DeliveredResult
     originalStates = new Map();
     store;
-    claimPolicy;
     constructor(config, store) {
         this.config = config;
         this.store = store;
-        this.claimPolicy = config.claimPolicy ?? new AcceptAllPolicy();
     }
     async initialize() {
         const chain = this.config.chainId === 84532 ? baseSepolia : base;
@@ -64,102 +60,74 @@ export class MechAdapter {
         this.deliveryBlockCursor = blockNumber;
         // Recover pending state from on-chain events
         if (this.store) {
+            this.loadPendingEvaluationSolutions();
             await this.recoverPendingState(blockNumber);
         }
     }
     async recoverPendingState(currentBlock) {
         const fromBlock = this.store?.getLastProcessedBlock() ?? currentBlock;
-        if (fromBlock >= currentBlock)
-            return;
-        console.error(`[mech] Recovering pending state from block ${fromBlock} to ${currentBlock}`);
-        // Scan for restoration jobs this creator posted
-        const restorations = await scanTasks(this.publicClient, this.config.routerAddress, this.config.safeAddress, fromBlock, currentBlock);
-        // Scan for evaluation jobs this creator posted
-        const evaluations = await scanEvaluationJobs(this.publicClient, this.config.routerAddress, this.config.safeAddress, fromBlock, currentBlock);
-        // Build set of restoration IDs that already have evaluation jobs
-        const hasEvaluation = new Set(evaluations.map(e => e.restorationRequestId));
-        // Check each restoration's delivery status
-        for (const restoration of restorations) {
-            if (hasEvaluation.has(restoration.requestId)) {
-                // Evaluation already created — check if eval delivery needs claiming
-                const evalJob = evaluations.find(e => e.restorationRequestId === restoration.requestId);
-                if (evalJob) {
-                    const evalInfo = await this.publicClient.readContract({
-                        address: this.config.mechMarketplaceAddress,
-                        abi: MECH_MARKETPLACE_ABI,
-                        functionName: 'mapRequestIdInfos',
-                        args: [evalJob.requestId],
-                    });
-                    if (evalInfo[1] === '0x0000000000000000000000000000000000000000') {
-                        // Evaluation not yet delivered — track it
-                        this.pendingEvaluationClaims.add(evalJob.requestId);
-                    }
-                    // If delivered, fully complete — nothing to track
-                }
-                continue;
-            }
-            // No evaluation job yet — check delivery status
-            const info = await this.publicClient.readContract({
-                address: this.config.mechMarketplaceAddress,
-                abi: MECH_MARKETPLACE_ABI,
-                functionName: 'mapRequestIdInfos',
-                args: [restoration.requestId],
-            });
-            const deliveryMech = info[1];
-            if (deliveryMech === '0x0000000000000000000000000000000000000000') {
-                // Not delivered yet — track for evaluation after delivery
-                this.pendingEvaluations.set(restoration.requestId, {
-                    id: restoration.requestId,
-                    description: '', // Original description not available from events, but not needed for evaluation creation
-                });
-            }
-            else {
-                // Delivered but no evaluation — needs claim + evaluation creation
-                this.pendingEvaluations.set(restoration.requestId, {
-                    id: restoration.requestId,
-                    description: '',
-                });
-                this.claimedButNotEvaluated.add(restoration.requestId);
-            }
+        if (fromBlock < currentBlock) {
+            console.error(`[mech] TaskCoordinator clean-break recovery starts at block ${fromBlock}; ` +
+                'old request-first recovery is intentionally disabled');
+            this.deliveryBlockCursor = fromBlock;
         }
-        // Set delivery block cursor to scan from recovery point
-        this.deliveryBlockCursor = fromBlock;
-        const latestRequestDataByRid = await scanLatestRequestDataByRid(this.publicClient, this.config.mechMarketplaceAddress, fromBlock, currentBlock);
-        const latestDeliveryDataByRid = await scanLatestDeliveryDataByRid(this.publicClient, this.config.mechContractAddress, fromBlock, currentBlock);
-        for (const { requestId } of restorations) {
-            const pe = this.pendingEvaluations.get(requestId);
-            if (!pe)
-                continue;
-            const requestDataHex = latestRequestDataByRid.get(requestId.toLowerCase());
-            if (requestDataHex) {
-                const d = String(requestDataHex);
-                const digest = d.startsWith('0x') ? d.slice(2) : d;
-                this.pendingEvaluations.set(requestId, {
-                    ...pe,
-                    context: { ...pe.context, [RESTORATION_TASK_CID_CONTEXT_KEY]: `f01551220${digest}` },
-                });
-            }
-            const deliveryDataHex = latestDeliveryDataByRid.get(requestId.toLowerCase());
-            if (deliveryDataHex) {
-                try {
-                    const d = String(deliveryDataHex);
-                    const dig = d.startsWith('0x') ? d.slice(2) : d;
-                    const envelopeCid = `f01551220${dig}`;
-                    const payload = (await fetchFromIpfs(this.config.ipfsGatewayUrl, envelopeCid));
-                    this.pendingEvaluationResults.set(requestId, payload.data ?? JSON.stringify(payload));
-                    this.pendingEvaluationResultCids.set(requestId, envelopeCid);
-                    this.backfillMissRids.delete(requestId);
-                }
-                catch (err) {
-                    console.error(`[mech] recovery: could not load restoration result IPFS for ${requestId}:`, err);
+        const routerCursorRaw = this.store?.getConfigValue(ROUTER_REQUEST_CURSOR_CONFIG_KEY);
+        const routerFromBlock = routerCursorRaw != null
+            ? BigInt(routerCursorRaw)
+            : fromBlock;
+        if (routerFromBlock < currentBlock) {
+            this.requestBlockCursor = routerFromBlock;
+        }
+    }
+    loadPendingEvaluationSolutions() {
+        const raw = this.store?.getConfigValue(PENDING_EVALUATION_SOLUTIONS_CONFIG_KEY);
+        if (!raw)
+            return;
+        try {
+            const parsed = JSON.parse(raw);
+            if (!Array.isArray(parsed))
+                return;
+            for (const value of parsed) {
+                if (value == null || typeof value !== 'object')
+                    continue;
+                const item = value;
+                if (typeof item.taskId !== 'string' ||
+                    typeof item.requestId !== 'string' ||
+                    typeof item.operator !== 'string' ||
+                    typeof item.attemptIndex !== 'number') {
+                    continue;
                 }
+                const solution = {
+                    taskId: item.taskId,
+                    attemptIndex: item.attemptIndex,
+                    requestId: item.requestId,
+                    operator: item.operator,
+                    transactionHash: typeof item.transactionHash === 'string'
+                        ? item.transactionHash
+                        : undefined,
+                    blockNumber: typeof item.blockNumber === 'number' ? item.blockNumber : undefined,
+                };
+                this.pendingEvaluationSolutions.set(solution.requestId, solution);
             }
         }
-        const recovered = this.pendingEvaluations.size + this.pendingEvaluationClaims.size + this.claimedButNotEvaluated.size;
-        if (recovered > 0) {
-            console.error(`[mech] Recovered: ${this.pendingEvaluations.size} pending evaluations, ${this.pendingEvaluationClaims.size} pending eval claims, ${this.claimedButNotEvaluated.size} claimed but not evaluated`);
+        catch (err) {
+            console.error('[mech] Failed to load pending evaluation solutions:', err);
         }
     }
+    persistPendingEvaluationSolutions() {
+        if (!this.store)
+            return;
+        this.store.setConfigValue(PENDING_EVALUATION_SOLUTIONS_CONFIG_KEY, JSON.stringify(Array.from(this.pendingEvaluationSolutions.values())));
+    }
+    rememberPendingEvaluationSolution(solution) {
+        this.pendingEvaluationSolutions.set(solution.requestId, solution);
+        this.persistPendingEvaluationSolutions();
+    }
+    forgetPendingEvaluationSolution(requestId) {
+        if (!this.pendingEvaluationSolutions.delete(requestId))
+            return;
+        this.persistPendingEvaluationSolutions();
+    }
     async postTask(state) {
         const restorationState = {
             ...state,
@@ -177,25 +145,27 @@ export class MechAdapter {
         const restorationTaskCid = `f01551220${digestNo0x}`;
         const deliveryRate = await getMechDeliveryRate(this.publicClient, this.config.mechContractAddress);
         const { max: maxTimeout } = await getTimeoutBounds(this.publicClient, this.config.mechMarketplaceAddress);
-        const taskSubmission = await submitTask(this.publicClient, this.walletClient, this.config.safeAddress, this.config.routerAddress, this.config.mechContractAddress, restorationDataHex, deliveryRate, maxTimeout, this.config.evictionRecovery);
-        const restorationRequestIds = taskSubmission.requestIds;
-        if (restorationRequestIds.length === 0) {
-            throw new PermanentError('No request IDs returned from router ' +
-                `(tx=${taskSubmission.txHash}, router=${this.config.routerAddress}, safe=${this.config.safeAddress}, ` +
-                `mech=${this.config.mechContractAddress}, receiptLogs=${taskSubmission.receiptLogCount}, chainId=${this.config.chainId})`);
-        }
-        const restorationRequestId = restorationRequestIds[0];
-        // Store for evaluation creation after delivery is claimed. The evaluation
-        // job’s IPFS CID is different from the restoration intended-state CID; evaluators
-        // need the latter to verify submission.signedTask.cid (see context.restorationTaskCid).
-        const stateForEval = {
-            ...state,
-            signedTask,
-            context: { ...(state.context ?? {}), [RESTORATION_TASK_CID_CONTEXT_KEY]: restorationTaskCid },
+        const solverTypeDigest = keccak256(toBytes(signedTask.solverType));
+        const policy = this.contractPolicyForTask(restorationState);
+        const taskSubmission = await submitTask(this.publicClient, this.walletClient, this.config.safeAddress, this.config.routerAddress, restorationDataHex, solverTypeDigest, policy, deliveryRate, deliveryRate, maxTimeout, this.config.evictionRecovery);
+        const announcement = {
+            taskId: taskSubmission.taskId,
+            task: {
+                ...restorationState,
+                signedTask,
+                context: { ...(restorationState.context ?? {}), [RESTORATION_TASK_CID_CONTEXT_KEY]: restorationTaskCid },
+            },
+            taskCid: restorationTaskCid,
+            onchainCreationTx: taskSubmission.txHash,
+            onchainCreationBlock: taskSubmission.blockNumber,
+        };
+        this.observedTasks.set(taskSubmission.taskId, announcement);
+        return {
+            taskId: taskSubmission.taskId,
+            taskCid: restorationTaskCid,
+            txHash: taskSubmission.txHash,
+            blockNumber: taskSubmission.blockNumber,
         };
-        this.pendingEvaluations.set(restorationRequestId, stateForEval);
-        this.originalStates.set(restorationRequestId, { ...stateForEval, role: 'restoration' });
-        return restorationRequestId;
     }
     async signTaskDocument(state) {
         const now = Date.now();
@@ -218,6 +188,7 @@ export class MechAdapter {
             window: state.window ?? { startTs: now, endTs: now + 86_400_000 },
             spec: state.spec ?? {},
             eligibility: state.eligibility ?? {},
+            claimPolicy: state.claimPolicy ?? DEFAULT_MECH_CLAIM_POLICY,
             creator: {
                 safeAddress: getAddress(this.config.safeAddress),
                 agentEoa: account.address,
@@ -227,24 +198,159 @@ export class MechAdapter {
         };
         return signTaskV1(taskDoc, this.config.agentEoaPrivateKey);
     }
-    async *watchForRequests() {
+    contractPolicyForTask(state) {
+        const nowSeconds = Math.floor(Date.now() / 1000);
+        const claimPolicy = state.claimPolicy ?? DEFAULT_MECH_CLAIM_POLICY;
+        const normalizeTs = (value, fallback) => {
+            const raw = value ?? fallback;
+            return BigInt(raw > 10_000_000_000 ? Math.floor(raw / 1000) : raw);
+        };
+        const claimWindowStart = normalizeTs(claimPolicy.claimWindowStartTs ?? state.window?.startTs, nowSeconds);
+        const claimWindowEnd = normalizeTs(claimPolicy.claimWindowEndTs ?? state.window?.endTs, nowSeconds + 30 * 60);
+        const submissionDeadline = normalizeTs(claimPolicy.submissionDeadlineTs, Number(claimWindowEnd) + claimPolicy.claimLeaseTtlSeconds);
+        return {
+            claimWindowStart,
+            claimWindowEnd,
+            submissionDeadline,
+            claimLeaseTtlSeconds: claimPolicy.claimLeaseTtlSeconds,
+            maxClaims: claimPolicy.maxClaims,
+            maxClaimsPerOperator: claimPolicy.maxClaimsPerOperator,
+            policyHook: (claimPolicy.policyHook ?? zeroAddress),
+            evaluationPolicy: {
+                requiredVerdicts: 1,
+                passThreshold: 1,
+                evaluationDeadline: submissionDeadline + BigInt(claimPolicy.claimLeaseTtlSeconds),
+                maxVerdictsPerEvaluator: 1,
+                disallowSolverSelfEvaluation: true,
+            },
+        };
+    }
+    buildEvaluationTask(params) {
+        return {
+            ...params.task,
+            id: `${params.task.id}:evaluation:${params.attemptIndex}`,
+            role: 'evaluation',
+            restorationRequestId: params.solutionRequestId,
+            attemptId: params.solutionRequestId,
+            attemptNumber: params.attemptIndex,
+            context: {
+                ...(params.task.context ?? {}),
+                restorationResult: params.resultData,
+                [RESTORATION_TASK_CID_CONTEXT_KEY]: params.task.context?.[RESTORATION_TASK_CID_CONTEXT_KEY] ?? params.taskCid,
+                [RESTORATION_ENVELOPE_CID_CONTEXT_KEY]: params.restorationEnvelopeCid,
+            },
+        };
+    }
+    async restorationAnnouncementForTaskId(taskId) {
+        const cached = this.observedTasks.get(taskId);
+        if (cached)
+            return cached;
+        const taskCidDigest = await getTaskCidDigest(this.publicClient, this.config.routerAddress, taskId);
+        const digest = taskCidDigest.startsWith('0x') ? taskCidDigest.slice(2) : taskCidDigest;
+        const taskCid = `f01551220${digest}`;
+        const signed = await fetchSignedTaskFromIpfs(this.config.ipfsGatewayUrl, taskCid);
+        const task = parseTask({ signedTask: signed });
+        const announcement = {
+            taskId,
+            task,
+            taskCid,
+        };
+        this.observedTasks.set(taskId, announcement);
+        return announcement;
+    }
+    async deliveryEnvelopeCidForSolution(solution) {
+        const deliveryMech = await getMarketplaceRequestDeliveryMech(this.publicClient, this.config.mechMarketplaceAddress, solution.requestId);
+        const toBlock = solution.blockNumber != null
+            ? BigInt(solution.blockNumber)
+            : await this.publicClient.getBlockNumber();
+        const configuredLookback = this.config.mechDeliverBackfillLookbackBlocks;
+        const fromBlock = configuredLookback == null
+            ? 0n
+            : toBlock > configuredLookback
+                ? toBlock - configuredLookback
+                : 0n;
+        const deliveryDataHex = await findLatestDeliveryDataHexForRequest(this.publicClient, deliveryMech, solution.requestId, fromBlock, toBlock);
+        if (!deliveryDataHex) {
+            throw new Error(`No Deliver event data found for solution ${solution.requestId} on mech ${deliveryMech} ` +
+                `between blocks ${fromBlock} and ${toBlock}`);
+        }
+        const digest = deliveryDataHex.startsWith('0x') ? deliveryDataHex.slice(2) : deliveryDataHex;
+        return `f01551220${digest}`;
+    }
+    async evaluationAnnouncementForSolution(solution) {
+        if (solution.operator.toLowerCase() === this.config.safeAddress.toLowerCase()) {
+            return undefined;
+        }
+        const restoration = await this.restorationAnnouncementForTaskId(solution.taskId);
+        const restorationEnvelopeCid = await this.deliveryEnvelopeCidForSolution(solution);
+        const resultPayload = await fetchFromIpfs(this.config.ipfsGatewayUrl, restorationEnvelopeCid);
+        const resultData = resultPayload.data ?? JSON.stringify(resultPayload);
+        const evaluationTask = this.buildEvaluationTask({
+            task: restoration.task,
+            solutionRequestId: solution.requestId,
+            attemptIndex: solution.attemptIndex,
+            resultData,
+            restorationEnvelopeCid,
+            taskCid: restoration.taskCid,
+        });
+        const opportunityId = `evaluation:${solution.taskId}:${solution.attemptIndex}:${solution.requestId}`;
+        const announcement = {
+            taskId: opportunityId,
+            task: evaluationTask,
+            taskCid: restoration.taskCid,
+            onchainCreationTx: solution.transactionHash,
+            onchainCreationBlock: solution.blockNumber,
+        };
+        this.evaluationOpportunities.set(opportunityId, {
+            taskId: solution.taskId,
+            attemptIndex: solution.attemptIndex,
+            task: evaluationTask,
+        });
+        this.observedTasks.set(opportunityId, announcement);
+        return announcement;
+    }
+    async *retryPendingEvaluationSolutions() {
+        for (const [requestId, solution] of Array.from(this.pendingEvaluationSolutions)) {
+            try {
+                const announcement = await this.evaluationAnnouncementForSolution(solution);
+                if (announcement) {
+                    yield announcement;
+                }
+                else {
+                    this.forgetPendingEvaluationSolution(requestId);
+                }
+            }
+            catch (err) {
+                console.error(`[mech] evaluation opportunity retry failed for ${requestId}:`, err);
+            }
+        }
+    }
+    async *watchForTasks() {
         while (!this.stopped) {
             try {
+                for await (const announcement of this.retryPendingEvaluationSolutions()) {
+                    yield announcement;
+                }
                 const currentBlock = await this.publicClient.getBlockNumber();
                 if (currentBlock > this.requestBlockCursor) {
+                    const fromBlock = this.requestBlockCursor + 1n;
                     const logs = await this.publicClient.getLogs({
-                        address: this.config.mechMarketplaceAddress,
-                        fromBlock: this.requestBlockCursor + 1n,
+                        address: this.config.routerAddress,
+                        fromBlock,
                         toBlock: currentBlock,
                     });
+                    const submittedSolutions = decodeSolutionDeliveryClaimedLogs(logs);
+                    for (const solution of submittedSolutions) {
+                        this.rememberPendingEvaluationSolution(solution);
+                    }
                     this.requestBlockCursor = currentBlock;
-                    const decoded = decodeMarketplaceRequestLogs(logs);
-                    for (const { requestId, requestDataHex, priorityMech, transactionHash, blockNumber } of decoded) {
-                        if (!this.claimPolicy.shouldAccept({ requestId, requestDataHex, priorityMech })) {
-                            continue;
-                        }
+                    if (this.store) {
+                        this.store.setConfigValue(ROUTER_REQUEST_CURSOR_CONFIG_KEY, currentBlock.toString());
+                    }
+                    const createdTasks = decodeTaskCreatedLogs(logs);
+                    for (const { taskId, taskCidDigest, transactionHash, blockNumber } of createdTasks) {
                         try {
-                            const digest = requestDataHex.startsWith('0x') ? requestDataHex.slice(2) : requestDataHex;
+                            const digest = taskCidDigest.startsWith('0x') ? taskCidDigest.slice(2) : taskCidDigest;
                             // CIDv1 hex with raw codec (0x55) + sha2-256 (0x12) + 32-byte length (0x20).
                             // The Autonolas registry returns raw-codec CIDs when uploading files with
                             // cid-version=1 (Kubo default for files). This is confirmed by the existing
@@ -253,37 +359,80 @@ export class MechAdapter {
                             const taskCid = `f01551220${digest}`;
                             const signed = await fetchSignedTaskFromIpfs(this.config.ipfsGatewayUrl, taskCid);
                             const task = parseTask({ signedTask: signed });
-                            yield {
-                                requestId,
+                            const announcement = {
+                                taskId,
                                 task,
                                 taskCid,
                                 onchainCreationTx: transactionHash,
                                 onchainCreationBlock: blockNumber,
                             };
+                            this.observedTasks.set(taskId, announcement);
+                            yield announcement;
                         }
                         catch (err) {
-                            console.error(`[mech] Failed to parse request ${requestId}:`, err);
+                            console.error(`[mech] Failed to parse task ${taskId}:`, err);
                         }
                     }
+                    for await (const announcement of this.retryPendingEvaluationSolutions()) {
+                        yield announcement;
+                    }
                 }
             }
             catch (err) {
-                console.error('[mech] Error polling for requests:', formatRpcError(err, {
-                    operation: 'pollMarketplaceRequests',
+                console.error('[mech] Error polling for tasks:', formatRpcError(err, {
+                    operation: 'pollTaskCreated',
                     chain: this.config.chainId === 84532 ? 'base-sepolia' : 'base',
                     rpcUrl: this.config.rpcUrl,
-                    contract: this.config.mechMarketplaceAddress,
+                    contract: this.config.routerAddress,
                     fromBlock: this.requestBlockCursor + 1n,
                 }));
             }
             await new Promise(r => setTimeout(r, this.config.pollIntervalMs));
         }
     }
-    async claimRequest(requestId) {
-        const allowed = await this.claimPolicy.confirmClaim(requestId);
-        if (!allowed) {
-            throw new PermanentError(`Claim policy rejected request ${requestId}`);
+    async claimTask(taskId) {
+        const evaluationOpportunity = this.evaluationOpportunities.get(taskId);
+        if (evaluationOpportunity) {
+            const signedEvaluationTask = await this.signTaskDocument(evaluationOpportunity.task);
+            const evaluationCid = await uploadToIpfs(this.config.ipfsRegistryUrl, signedEvaluationTask);
+            const evaluationTaskCidDigest = cidToDigestHex(evaluationCid);
+            const claimed = await this.claimEvaluation(evaluationOpportunity.taskId, evaluationOpportunity.attemptIndex, evaluationTaskCidDigest);
+            this.pendingEvaluations.set(claimed.requestId, evaluationOpportunity.task);
+            this.originalStates.set(claimed.requestId, evaluationOpportunity.task);
+            this.requestKinds.set(claimed.requestId, 'verdict');
+            this.evaluationOpportunities.delete(taskId);
+            const solutionRequestId = evaluationOpportunity.task.restorationRequestId;
+            if (solutionRequestId) {
+                this.forgetPendingEvaluationSolution(solutionRequestId);
+            }
+            return {
+                requestId: claimed.requestId,
+                taskId: claimed.taskId,
+                attemptIndex: claimed.attemptIndex,
+                task: evaluationOpportunity.task,
+                taskCid: evaluationCid,
+                onchainCreationTx: claimed.txHash,
+                onchainCreationBlock: claimed.blockNumber,
+            };
         }
+        const announcement = this.observedTasks.get(taskId);
+        if (!announcement) {
+            throw new PermanentError(`Cannot claim unknown task ${taskId}`);
+        }
+        const claimed = await claimTaskOnchain(this.publicClient, this.walletClient, this.config.safeAddress, this.config.routerAddress, taskId, this.config.mechContractAddress, this.config.evictionRecovery);
+        const task = announcement.task;
+        this.pendingEvaluations.set(claimed.requestId, task);
+        this.originalStates.set(claimed.requestId, { ...task, role: task.role ?? 'restoration' });
+        this.requestKinds.set(claimed.requestId, 'solution');
+        return {
+            requestId: claimed.requestId,
+            taskId: claimed.taskId,
+            attemptIndex: claimed.attemptIndex,
+            task,
+            taskCid: announcement.taskCid,
+            onchainCreationTx: claimed.txHash,
+            onchainCreationBlock: claimed.blockNumber,
+        };
     }
     async submitResult(requestId, result) {
         const payload = buildResultPayload(requestId, result);
@@ -292,9 +441,21 @@ export class MechAdapter {
         // Safe → AgentMech.deliverToMarketplace() → Marketplace.deliverMarketplace()
         await callDeliverToMarketplace(this.publicClient, this.walletClient, this.config.safeAddress, this.config.mechContractAddress, [requestId], [deliveryDigest], this.config.evictionRecovery);
     }
+    async claimEvaluation(taskId, attemptIndex, evaluationTaskCidDigest) {
+        const claimed = await claimEvaluationOnchain(this.publicClient, this.walletClient, this.config.safeAddress, this.config.routerAddress, taskId, attemptIndex, this.config.mechContractAddress, evaluationTaskCidDigest, this.config.evictionRecovery);
+        this.requestKinds.set(claimed.requestId, 'verdict');
+        return claimed;
+    }
+    async submitSolutionDelivery(requestId, solutionDigest) {
+        await claimDelivery(this.publicClient, this.walletClient, this.config.safeAddress, this.config.routerAddress, requestId, { variant: 'v3', kind: 'solution', evidenceHash: solutionDigest }, this.config.evictionRecovery);
+    }
+    async submitVerdictDelivery(requestId, verdictDigest, verdictCode = 1) {
+        await claimDelivery(this.publicClient, this.walletClient, this.config.safeAddress, this.config.routerAddress, requestId, { variant: 'v3', kind: 'verdict', evidenceHash: verdictDigest, verdictCode }, this.config.evictionRecovery);
+    }
     async evidenceHashForDelivery(requestId, deliveryDataHex) {
-        if (this.config.routerClaimDeliveryVariant !== 'v2')
+        if (this.config.routerClaimDeliveryVariant !== 'v2' && this.config.routerClaimDeliveryVariant !== 'v3') {
             return undefined;
+        }
         const deliveryDigest = deliveryDataHex.startsWith('0x')
             ? deliveryDataHex.slice(2)
             : deliveryDataHex;
@@ -320,7 +481,11 @@ export class MechAdapter {
             return 'retry';
         }
         try {
-            await claimDelivery(this.publicClient, this.walletClient, this.config.safeAddress, this.config.routerAddress, requestId, { variant: this.config.routerClaimDeliveryVariant, evidenceHash }, this.config.evictionRecovery);
+            await claimDelivery(this.publicClient, this.walletClient, this.config.safeAddress, this.config.routerAddress, requestId, {
+                variant: this.config.routerClaimDeliveryVariant,
+                kind: this.requestKinds.get(requestId) ?? 'solution',
+                evidenceHash,
+            }, this.config.evictionRecovery);
             return 'claimed';
         }
         catch (err) {
@@ -353,12 +518,10 @@ export class MechAdapter {
                         //   (a) Did this Safe DELIVER this? → claim it (counter credit goes to msg.sender)
                         //       The Deliver event's mechAddress is mechServiceMultisig (the Safe that owns
                         //       the mech), so we compare against this.config.safeAddress.
-                        //   (b) Did this Safe CREATE the underlying request? → act on the delivery
-                        //       (trigger eval creation for restoration deliveries; clean up for eval deliveries)
+                        //   (b) Did this Safe claim the underlying Task? → act on the delivery.
                         const iDelivered = mechAddress.toLowerCase() === this.config.safeAddress.toLowerCase();
                         const iCreatedRestoration = this.pendingEvaluations.has(requestId);
-                        const iCreatedEvaluation = this.pendingEvaluationClaims.has(requestId);
-                        if (!iDelivered && !iCreatedRestoration && !iCreatedEvaluation)
+                        if (!iDelivered && !iCreatedRestoration)
                             continue;
                         // (a) Deliverer-side claim path: if this Safe delivered the request,
                         //     claim it first so router counters credit the deliverer.
@@ -368,40 +531,14 @@ export class MechAdapter {
                             if (deliveryClaimStatus === 'retry')
                                 continue;
                         }
-                        // (b) Creator-side claim path: we created the restoration, so the
-                        //     router needs `restorationDeliveryClaimed` flipped before
-                        //     `createEvaluationJob` can fire. Production engine deliveries
-                        //     usually claim atomically; this call is idempotent and also
-                        //     covers legacy/test adapter deliveries that only wrote to the
-                        //     marketplace.
+                        // (b) Task-side claim path: if this request came from our Task
+                        //     claim, make sure JinnRouterV3 records the Solution submission.
                         if (iCreatedRestoration && deliveryClaimStatus !== 'claimed' && deliveryClaimStatus !== 'already-claimed') {
                             const creatorClaimStatus = await this.ensureDeliveryClaimed(requestId, deliveryDataHex);
                             if (creatorClaimStatus === 'retry')
                                 continue;
                         }
-                        // (c) If I created the restoration, post the eval job once the claim is on-chain.
-                        //     The deliverer (someone else, or us if we also delivered) must have claimed first.
-                        //     tryCreateEvaluationJob calls verifyRestorationClaimed() which polls for the claim.
-                        if (iCreatedRestoration) {
-                            let restorationResultData;
-                            let restorationEnvelopeCid;
-                            try {
-                                const digest = deliveryDataHex.startsWith('0x') ? deliveryDataHex.slice(2) : deliveryDataHex;
-                                restorationEnvelopeCid = `f01551220${digest}`;
-                                const payload = await fetchFromIpfs(this.config.ipfsGatewayUrl, restorationEnvelopeCid);
-                                restorationResultData = payload.data ?? JSON.stringify(payload);
-                                this.backfillMissRids.delete(requestId);
-                            }
-                            catch (err) {
-                                console.error(`[mech] Failed to fetch restoration result for evaluation: ${requestId}`, err);
-                            }
-                            await this.tryCreateEvaluationJob(requestId, restorationResultData, restorationEnvelopeCid);
-                        }
-                        // (d) If I created the evaluation, clean up tracking once delivered.
-                        if (iCreatedEvaluation) {
-                            this.pendingEvaluationClaims.delete(requestId);
-                        }
-                        // (e) Yield the delivery result.
+                        // (c) Yield the delivery result.
                         try {
                             const deliveryDigest = deliveryDataHex.startsWith('0x') ? deliveryDataHex.slice(2) : deliveryDataHex;
                             const resultPayload = await fetchFromIpfs(this.config.ipfsGatewayUrl, `f01551220${deliveryDigest}`);
@@ -422,18 +559,14 @@ export class MechAdapter {
                             };
                             // Clean up after yielding
                             this.originalStates.delete(requestId);
+                            this.pendingEvaluations.delete(requestId);
+                            this.requestKinds.delete(requestId);
                         }
                         catch (err) {
                             console.error(`[mech] Failed to parse delivery ${requestId}:`, err);
                         }
                     }
                 }
-                // After new Deliver events are processed (and `pendingEvaluationResults` may be warm),
-                // retry evaluation creation. Doing this *before* deliver processing can upload an
-                // evaluation Task without `restorationResult` in context.
-                for (const rid of [...this.claimedButNotEvaluated]) {
-                    await this.tryCreateEvaluationJob(rid);
-                }
             }
             catch (err) {
                 console.error('[mech] Error polling for deliveries:', formatRpcError(err, {
@@ -451,134 +584,6 @@ export class MechAdapter {
             await new Promise(r => setTimeout(r, this.config.pollIntervalMs));
         }
     }
-    async backfillRestorationResultFromChain(requestId) {
-        if (this.pendingEvaluationResults.has(requestId)) {
-            return this.pendingEvaluationResults.get(requestId);
-        }
-        if (this.backfillMissRids.has(requestId)) {
-            return undefined;
-        }
-        const currentBlock = await this.publicClient.getBlockNumber();
-        const lookbackBlocks = this.config.mechDeliverBackfillLookbackBlocks ?? 500000n;
-        const from = currentBlock > lookbackBlocks
-            ? currentBlock - lookbackBlocks
-            : 1n;
-        const dhex = await findLatestDeliveryDataHexForRequest(this.publicClient, this.config.mechContractAddress, requestId, from, currentBlock);
-        if (!dhex) {
-            this.backfillMissRids.add(requestId);
-            return undefined;
-        }
-        try {
-            const d = String(dhex);
-            const dig = d.startsWith('0x') ? d.slice(2) : d;
-            const envelopeCid = `f01551220${dig}`;
-            const payload = (await fetchFromIpfs(this.config.ipfsGatewayUrl, envelopeCid));
-            const data = payload.data ?? JSON.stringify(payload);
-            this.pendingEvaluationResults.set(requestId, data);
-            this.pendingEvaluationResultCids.set(requestId, envelopeCid);
-            this.backfillMissRids.delete(requestId);
-            return data;
-        }
-        catch (err) {
-            console.error(`[mech] backfill: failed to load restoration result for ${requestId}:`, err);
-            return undefined;
-        }
-    }
-    async tryCreateEvaluationJob(requestId, restorationResultData, restorationEnvelopeCid) {
-        if (!this.pendingEvaluations.has(requestId))
-            return;
-        const originalState = this.pendingEvaluations.get(requestId);
-        if (restorationResultData) {
-            this.pendingEvaluationResults.set(requestId, restorationResultData);
-            this.backfillMissRids.delete(requestId);
-        }
-        if (restorationEnvelopeCid) {
-            this.pendingEvaluationResultCids.set(requestId, restorationEnvelopeCid);
-        }
-        let cachedRestorationResultData = restorationResultData ?? this.pendingEvaluationResults.get(requestId);
-        if (cachedRestorationResultData == null) {
-            cachedRestorationResultData = await this.backfillRestorationResultFromChain(requestId);
-        }
-        if (cachedRestorationResultData == null) {
-            this.claimedButNotEvaluated.add(requestId);
-            console.error(`[mech] no restoration result yet for ${requestId} (evaluation job and IPFS upload deferred until Deliver or backfill)`);
-            return;
-        }
-        const cachedEnvelopeCid = restorationEnvelopeCid ?? this.pendingEvaluationResultCids.get(requestId);
-        try {
-            const evaluationState = {
-                ...originalState,
-                role: 'evaluation',
-                restorationRequestId: requestId,
-                context: {
-                    ...originalState.context,
-                    restorationResult: cachedRestorationResultData,
-                    ...(cachedEnvelopeCid ? { [RESTORATION_ENVELOPE_CID_CONTEXT_KEY]: cachedEnvelopeCid } : {}),
-                },
-            };
-            const evaluationPayload = await this.signTaskDocument(evaluationState);
-            const evaluationCid = await uploadToIpfs(this.config.ipfsRegistryUrl, evaluationPayload);
-            const evaluationDataHex = cidToDigestHex(evaluationCid);
-            // Verify the restoration claim landed on-chain before submitting.
-            // RPC load balancers can serve stale state right after a write,
-            // causing the router's restorationDeliveryClaimed check to fail
-            // with RestorationNotClaimed (surfaces as Safe GS013).
-            const isClaimed = await this.verifyRestorationClaimed(requestId);
-            if (!isClaimed) {
-                console.error(`[mech] restorationDeliveryClaimed not yet visible for ${requestId} — will retry`);
-                this.claimedButNotEvaluated.add(requestId);
-                return;
-            }
-            const deliveryRate = await getMechDeliveryRate(this.publicClient, this.config.mechContractAddress);
-            const { max: maxTimeout } = await getTimeoutBounds(this.publicClient, this.config.mechMarketplaceAddress);
-            const evalRequestIds = await submitEvaluationJob(this.publicClient, this.walletClient, this.config.safeAddress, this.config.routerAddress, requestId, this.config.mechContractAddress, evaluationDataHex, deliveryRate, maxTimeout, this.config.evictionRecovery);
-            if (evalRequestIds.length > 0) {
-                this.pendingEvaluationClaims.add(evalRequestIds[0]);
-                // Copy original state to evaluation request ID so delivery can use it
-                const origState = this.originalStates.get(requestId);
-                if (origState) {
-                    this.originalStates.set(evalRequestIds[0], { ...origState, role: 'evaluation' });
-                }
-            }
-            // Success — clean up both tracking sets
-            this.pendingEvaluations.delete(requestId);
-            this.claimedButNotEvaluated.delete(requestId);
-            this.pendingEvaluationResults.delete(requestId);
-            this.pendingEvaluationResultCids.delete(requestId);
-        }
-        catch (err) {
-            console.error(`[mech] Failed to create evaluation job for ${requestId}:`, err);
-            // Track for retry on next poll cycle (doesn't require a new Deliver event)
-            this.claimedButNotEvaluated.add(requestId);
-        }
-    }
-    async verifyRestorationClaimed(requestId) {
-        // RPC / fork can lag right after claimDelivery; give more room than 5×2s so
-        // tryCreateEvaluationJob succeeds on the first watchForDeliveries pass when possible.
-        const MAX_POLLS = 12;
-        const POLL_DELAY_MS = 1_500;
-        const abi = [{
-                type: 'function',
-                name: 'restorationDeliveryClaimed',
-                inputs: [{ name: 'requestId', type: 'bytes32' }],
-                outputs: [{ name: '', type: 'bool' }],
-                stateMutability: 'view',
-            }];
-        for (let i = 0; i < MAX_POLLS; i++) {
-            const claimed = await this.publicClient.readContract({
-                address: this.config.routerAddress,
-                abi,
-                functionName: 'restorationDeliveryClaimed',
-                args: [requestId],
-            });
-            if (claimed)
-                return true;
-            if (i < MAX_POLLS - 1) {
-                await new Promise(r => setTimeout(r, POLL_DELAY_MS));
-            }
-        }
-        return false;
-    }
     async stop() {
         this.stopped = true;
     }