@jinn-network/client 0.1.2 → 0.1.3-canary.24b69ea4

package/dist/adapters/mech/adapter.js

@@ -1,14 +1,53 @@
+import { getAddress, zeroAddress } from 'viem';
+import { keccak256, toBytes } from 'viem';
+import { privateKeyToAccount } from 'viem/accounts';
 import { base, baseSepolia } from 'viem/chains';
-import { PermanentError } from '../../types/index.js';
+import { PermanentError, parseTask } from '../../types/index.js';
 import { createClients } from './safe.js';
-import { buildDesiredStatePayload, buildResultPayload, uploadToIpfs, cidToDigestHex, fetchFromIpfs, parseDesiredStateFromPayload, } from './ipfs.js';
-import { submitRestorationJob, submitEvaluationJob, claimDelivery, getMechDeliveryRate, getTimeoutBounds, decodeMarketplaceRequestLogs, decodeDeliverLogs, callDeliverToMarketplace, scanRestorationJobs, scanEvaluationJobs, scanLatestRequestDataByRid, scanLatestDeliveryDataByRid, findLatestDeliveryDataHexForRequest, } from './contracts.js';
-import { MECH_MARKETPLACE_ABI } from './types.js';
-import { AcceptAllPolicy } from './claim-policy.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, claimTask as claimTaskOnchain, claimEvaluation as claimEvaluationOnchain, claimDelivery, getMechDeliveryRate, getTimeoutBounds, decodeTaskCreatedLogs, decodeSolutionDeliveryClaimedLogs, decodeDeliverLogs, findLatestDeliveryDataHexForRequest, getMarketplaceRequestDeliveryMech, getTaskCidDigest, callDeliverToMarketplace, canClaimTask, canClaimEvaluation, } from './contracts.js';
+import { queryClaimableTaskCandidates, } from './task-subgraph.js';
 import { withRecoverableRetry } from '../../tx-retry.js';
 import { formatRpcError } from '../../rpc-error-context.js';
-import { computeEvidenceSimHash } from '../../earning/evidence-simhash.js';
-import { RESTORATION_INTENT_CID_CONTEXT_KEY } from '../../restorer/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_DELIVER_BACKFILL_LOOKBACK_BLOCKS = 100000n;
+const DEFAULT_MECH_CLAIM_POLICY = {
+    mode: 'exclusive',
+    maxClaims: 1,
+    maxClaimsPerOperator: 1,
+    claimLeaseTtlSeconds: 30 * 60,
+};
+/**
+ * Spec §14 (Task 24): a Task carries `contractId` + `contractVersion` (BINDING)
+ * and a derivable `solverType = `${contractId}.${contractVersion}``. When the
+ * caller only supplies a legacy `solverType`, derive the BINDING fields from
+ * its `<id>.<version>` shape; fall back to `('legacy', 'v0')` so signing never
+ * produces an empty BINDING field.
+ */
+function deriveSolverType(state) {
+    if (state.contractId && state.contractVersion) {
+        return `${state.contractId}.${state.contractVersion}`;
+    }
+    return 'legacy';
+}
+function deriveContractIdVersion(state, solverType) {
+    if (state.contractId && state.contractVersion) {
+        return { contractId: state.contractId, contractVersion: state.contractVersion };
+    }
+    const dot = solverType.lastIndexOf('.');
+    if (dot > 0 && dot < solverType.length - 1) {
+        return {
+            contractId: solverType.slice(0, dot),
+            contractVersion: solverType.slice(dot + 1),
+        };
+    }
+    return { contractId: solverType || 'legacy', contractVersion: 'v0' };
+}
 export class MechAdapter {
     name = 'mech';
     publicClient;
@@ -18,27 +57,18 @@ 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();
-    // RIDs with no delivery found in backfill window; avoids repeated 500k-block rescans.
-    backfillMissRids = new Set();
-    // Original desired states keyed by request ID (restoration and evaluation)
-    // so we can yield accurate desiredState in DeliveredResult
+    observedTasks = new Map();
+    requestKinds = new Map();
+    claimedRestorationTaskIds = new Set();
+    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();
-    // Most recently posted intent CID (IPFS); surfaced via getLastPostedIntentCid()
-    // for ERC-8004 registration in the posting service.
-    _lastPostedIntentCid;
     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;
@@ -59,202 +89,541 @@ 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 scanRestorationJobs(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_INTENT_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 payload = (await fetchFromIpfs(this.config.ipfsGatewayUrl, `f01551220${dig}`));
-                    this.pendingEvaluationResults.set(requestId, payload.data ?? JSON.stringify(payload));
-                    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);
         }
     }
-    getLastPostedIntentCid() {
-        return this._lastPostedIntentCid;
+    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 postDesiredState(state) {
+    async postTask(state) {
         const restorationState = {
             ...state,
-            type: state.type ?? 'restoration',
+            role: state.role ?? 'restoration',
             attemptId: state.attemptId,
             attemptNumber: state.attemptNumber,
         };
-        const restorationPayload = buildDesiredStatePayload(restorationState);
-        const restorationCid = await uploadToIpfs(this.config.ipfsRegistryUrl, restorationPayload);
+        const signedTask = state.signedTask ?? await this.signTaskDocument(restorationState);
+        // Upload the canonical signed Task document so watchers can verify and
+        // parse the same task.v1 shape the creator signed.
+        const ipfsDoc = signedTask;
+        const restorationCid = await uploadToIpfs(this.config.ipfsRegistryUrl, ipfsDoc);
         const restorationDataHex = cidToDigestHex(restorationCid);
         const digestNo0x = restorationDataHex.startsWith('0x') ? restorationDataHex.slice(2) : restorationDataHex;
-        const restorationIntentCid = `f01551220${digestNo0x}`;
-        // Expose for ERC-8004 registration (posting service reads this right after postDesiredState).
-        this._lastPostedIntentCid = restorationIntentCid;
+        const restorationTaskCid = `f01551220${digestNo0x}`;
         const deliveryRate = await getMechDeliveryRate(this.publicClient, this.config.mechContractAddress);
         const { max: maxTimeout } = await getTimeoutBounds(this.publicClient, this.config.mechMarketplaceAddress);
-        const restorationJob = await submitRestorationJob(this.publicClient, this.walletClient, this.config.safeAddress, this.config.routerAddress, this.config.mechContractAddress, restorationDataHex, deliveryRate, maxTimeout);
-        const restorationRequestIds = restorationJob.requestIds;
-        if (restorationRequestIds.length === 0) {
-            throw new PermanentError('No request IDs returned from router ' +
-                `(tx=${restorationJob.txHash}, router=${this.config.routerAddress}, safe=${this.config.safeAddress}, ` +
-                `mech=${this.config.mechContractAddress}, receiptLogs=${restorationJob.receiptLogCount}, chainId=${this.config.chainId})`);
+        // Task 24 (spec/2026-05-05-solvernet-creation-and-launch.md §14): the
+        // on-chain digest is now manifest-bound — `keccak256(manifestCid)` —
+        // replacing the prior `keccak256(solverType)` derivation. This makes
+        // operator eligibility per-launch, not per-protocol.
+        if (!signedTask.solverNetManifestCid) {
+            throw new PermanentError(`Cannot post task ${signedTask.id}: signed task is missing solverNetManifestCid ` +
+                `(BINDING — required for keccak256(manifestCid) digest derivation).`);
         }
-        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.intent.cid (see context.restorationIntentCid).
-        const stateForEval = {
-            ...state,
-            context: { ...(state.context ?? {}), [RESTORATION_INTENT_CID_CONTEXT_KEY]: restorationIntentCid },
+        const manifestDigest = keccak256(toBytes(signedTask.solverNetManifestCid));
+        const policy = this.contractPolicyForTask(restorationState);
+        const taskSubmission = await submitTask(this.publicClient, this.walletClient, this.config.safeAddress, this.config.routerAddress, restorationDataHex, manifestDigest, 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,
+        };
+    }
+    async signTaskDocument(state) {
+        const now = Date.now();
+        const account = privateKeyToAccount(this.config.agentEoaPrivateKey);
+        const extras = {};
+        if (state.context)
+            extras['context'] = state.context;
+        if (state.attemptId)
+            extras['attemptId'] = state.attemptId;
+        if (state.attemptNumber !== undefined)
+            extras['attemptNumber'] = state.attemptNumber;
+        if (state.restorationRequestId)
+            extras['restorationRequestId'] = state.restorationRequestId;
+        // Task 24: BINDING SolverNet manifest CID + contract id/version.
+        // The runtime Task may be missing them when the daemon falls back to
+        // ad-hoc posting paths (legacy / tests). For those we derive the
+        // contract id/version from solverType and require the caller to surface
+        // the missing manifest cid downstream — postTask() throws on missing
+        // solverNetManifestCid before submitTask is invoked.
+        if (!state.solverNetManifestCid) {
+            throw new PermanentError(`Cannot sign task ${state.id}: missing solverNetManifestCid ` +
+                `(BINDING — spec/2026-05-05-solvernet-creation-and-launch.md §14).`);
+        }
+        const solverType = state.solverType ?? deriveSolverType(state);
+        const { contractId, contractVersion } = deriveContractIdVersion(state, solverType);
+        const taskDoc = {
+            schemaVersion: 'task.v1',
+            id: state.id,
+            solverType,
+            contractId,
+            contractVersion,
+            solverNetManifestCid: state.solverNetManifestCid,
+            role: state.role ?? 'restoration',
+            description: state.description,
+            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,
+            },
+            createdAt: now,
+            ...extras,
+        };
+        return signTaskV1(taskDoc, this.config.agentEoaPrivateKey);
+    }
+    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,
+                // Allow the same operator to evaluate its own Solution on Base Sepolia
+                // (84532) so a single dogfood daemon can close the full
+                // post→claim→solve→grade→settle loop without standing up a second
+                // operator. Mainnet (8453) keeps the protocol-level protection.
+                // TODO: revert to unconditional `true` before mainnet launch, OR move
+                // this to a per-SolverNet manifest field so individual launchers can
+                // opt in to single-operator dogfood while the protocol default stays
+                // strict.
+                disallowSolverSelfEvaluation: this.config.chainId !== 84532,
+            },
+        };
+    }
+    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.pendingEvaluations.set(restorationRequestId, stateForEval);
-        this.originalStates.set(restorationRequestId, { ...stateForEval, type: 'restoration' });
-        return restorationRequestId;
+        this.observedTasks.set(taskId, announcement);
+        return announcement;
     }
-    async *watchForRequests() {
+    async restorationAnnouncementFromDigest(params) {
+        const digest = params.taskCidDigest.startsWith('0x')
+            ? params.taskCidDigest.slice(2)
+            : params.taskCidDigest;
+        const taskCid = `f01551220${digest}`;
+        const signed = await fetchSignedTaskFromIpfs(this.config.ipfsGatewayUrl, taskCid);
+        const task = parseTask({ signedTask: signed });
+        const announcement = {
+            taskId: params.taskId,
+            task,
+            taskCid,
+            onchainCreationTx: params.transactionHash,
+            onchainCreationBlock: params.blockNumber,
+        };
+        this.observedTasks.set(params.taskId, announcement);
+        return announcement;
+    }
+    async *discoverSubgraphRestorationTasks() {
+        const discovery = this.config.taskDiscovery;
+        const subgraphUrl = discovery?.subgraphUrl;
+        const solverNetManifestCids = discovery?.solverNetManifestCids ?? [];
+        if (!subgraphUrl || solverNetManifestCids.length === 0)
+            return;
+        let candidates;
+        try {
+            candidates = await queryClaimableTaskCandidates({
+                url: subgraphUrl,
+                solverNetManifestCids,
+                operatorAddress: this.config.safeAddress,
+                pageSize: discovery.pageSize,
+                maxPages: discovery.maxPages,
+                fetchImpl: discovery.fetchImpl,
+            });
+        }
+        catch (err) {
+            console.error('[mech] task subgraph discovery failed:', err instanceof Error ? err.message : err);
+            return;
+        }
+        for (const candidate of candidates) {
+            if (this.claimedRestorationTaskIds.has(candidate.taskId))
+                continue;
+            const claimable = await canClaimTask(this.publicClient, this.config.safeAddress, this.config.routerAddress, candidate.taskId, this.config.mechContractAddress);
+            if (!claimable.ok) {
+                continue;
+            }
+            try {
+                yield await this.restorationAnnouncementFromDigest({
+                    taskId: candidate.taskId,
+                    taskCidDigest: candidate.taskCidDigest,
+                    transactionHash: candidate.createdAtTx,
+                    blockNumber: candidate.createdAtBlock,
+                });
+                return;
+            }
+            catch (err) {
+                console.error(`[mech] failed to hydrate subgraph task ${candidate.taskId}:`, err instanceof Error ? err.message : err);
+            }
+        }
+    }
+    hasSubgraphTaskDiscovery() {
+        const discovery = this.config.taskDiscovery;
+        return Boolean(discovery?.subgraphUrl && (discovery.solverNetManifestCids?.length ?? 0) > 0);
+    }
+    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 lookback = this.config.mechDeliverBackfillLookbackBlocks ??
+            DEFAULT_MECH_DELIVER_BACKFILL_LOOKBACK_BLOCKS;
+        const fromBlock = toBlock > lookback ? toBlock - lookback : 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) {
+        const restoration = await this.restorationAnnouncementForTaskId(solution.taskId);
+        const claimable = await canClaimEvaluation(this.publicClient, this.config.safeAddress, this.config.routerAddress, solution.taskId, solution.attemptIndex, this.config.mechContractAddress);
+        if (!claimable.ok) {
+            console.log(`[mech] skipping evaluation opportunity ${solution.requestId} for task ${solution.taskId}/${solution.attemptIndex}: ${claimable.reason}`);
+            this.forgetPendingEvaluationSolution(solution.requestId);
+            return undefined;
+        }
+        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;
+                }
+                for await (const announcement of this.discoverSubgraphRestorationTasks()) {
+                    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;
-                        }
-                        try {
-                            const digest = requestDataHex.startsWith('0x') ? requestDataHex.slice(2) : requestDataHex;
-                            // 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
-                            // IPFS_GATEWAY_PREFIX constant (f01551220) which has worked in production.
-                            // If the gateway ever switches to dag-pb (0x70) the prefix would be f01701220.
-                            const intentCid = `f01551220${digest}`;
-                            const payload = await fetchFromIpfs(this.config.ipfsGatewayUrl, intentCid);
-                            const desiredState = parseDesiredStateFromPayload(payload);
-                            yield {
-                                requestId,
-                                desiredState,
-                                intentCid,
-                                onchainCreationTx: transactionHash,
-                                onchainCreationBlock: blockNumber,
-                            };
-                        }
-                        catch (err) {
-                            console.error(`[mech] Failed to parse request ${requestId}:`, err);
+                    if (this.store) {
+                        this.store.setConfigValue(ROUTER_REQUEST_CURSOR_CONFIG_KEY, currentBlock.toString());
+                    }
+                    if (!this.hasSubgraphTaskDiscovery()) {
+                        const createdTasks = decodeTaskCreatedLogs(logs);
+                        for (const { taskId, taskCidDigest, transactionHash, blockNumber } of createdTasks) {
+                            try {
+                                const announcement = await this.restorationAnnouncementFromDigest({
+                                    taskId,
+                                    taskCidDigest,
+                                    transactionHash,
+                                    blockNumber,
+                                });
+                                yield announcement;
+                            }
+                            catch (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.claimedRestorationTaskIds.add(claimed.taskId);
+        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);
         const cid = await uploadToIpfs(this.config.ipfsRegistryUrl, payload);
         const deliveryDigest = cidToDigestHex(cid);
         // Safe → AgentMech.deliverToMarketplace() → Marketplace.deliverMarketplace()
-        await callDeliverToMarketplace(this.publicClient, this.walletClient, this.config.safeAddress, this.config.mechContractAddress, [requestId], [deliveryDigest]);
+        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' && this.config.routerClaimDeliveryVariant !== 'v3') {
+            return undefined;
+        }
+        const deliveryDigest = deliveryDataHex.startsWith('0x')
+            ? deliveryDataHex.slice(2)
+            : deliveryDataHex;
+        const envelopeCid = `f01551220${deliveryDigest}`;
+        const rawEnvelope = await fetchSignedEnvelopeFromIpfs(this.config.ipfsGatewayUrl, envelopeCid);
+        const parsed = SignedEnvelopeSchema.parse(rawEnvelope);
+        // Strip signature to recompute the hash over the unsigned body.
+        //
+        // Important: compute over the fetched wire object, not over the parsed
+        // schema result. The schema normalizes some nested objects and may strip
+        // extension metadata that was present when the envelope was signed.
+        const rawSigned = rawEnvelope;
+        const { signature: _rawSignature, ...unsignedBody } = rawSigned;
+        const signature = parsed.signature;
+        const jcsBytes = new TextEncoder().encode(canonicalJson(unsignedBody));
+        const recomputed = keccak256(jcsBytes);
+        if (recomputed !== signature.hash) {
+            throw new Error(`recomputed hash ${recomputed} !== envelope.signature.hash ${signature.hash}`);
+        }
+        return recomputed;
+    }
+    async ensureDeliveryClaimed(requestId, deliveryDataHex) {
+        let evidenceHash;
+        try {
+            evidenceHash = await this.evidenceHashForDelivery(requestId, deliveryDataHex);
+        }
+        catch (err) {
+            console.error(`[mech] evidenceHash derivation failed for ${requestId} — skipping claim, will retry on next loop:`, err);
+            return 'retry';
+        }
+        try {
+            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) {
+            const message = err instanceof Error ? err.message : String(err);
+            if (message.includes('RequestNotFound')) {
+                console.error(`[mech] claimDelivery skipped (not a router request): ${requestId}`);
+                return 'skipped';
+            }
+            if (/already.*claimed|alreadyClaimed/i.test(message)) {
+                return 'already-claimed';
+            }
+            console.error(`[mech] claimDelivery failed for ${requestId}:`, err);
+            return 'retry';
+        }
     }
     async *watchForDeliveries() {
         while (!this.stopped) {
@@ -273,79 +642,27 @@ 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) Claim delivery on the router so `restorationDeliveryClaimed[requestId]` is set
-                        // (required before createEvaluationJob can run).
-                        // - Same-operator: we delivered (iDelivered) → our Safe claims and gets counter credit.
-                        // - Cross-operator: we created the request (iCreatedRestoration) but another mech
-                        //   delivered (iDelivered is false) → the creator Safe must still call claimDelivery
-                        //   so the router flips `restorationDeliveryClaimed` for this requestId. Otherwise
-                        //   tryCreateEvaluationJob never unblocks. See JinnRouter.claimDelivery in contracts.
-                        const shouldClaimDelivery = iDelivered || (iCreatedRestoration && !iDelivered);
-                        if (shouldClaimDelivery) {
-                            try {
-                                const variant = this.config.routerClaimDeliveryVariant;
-                                let evidenceHash;
-                                if (variant === 'v2') {
-                                    try {
-                                        const checkpoint = {
-                                            version: 1,
-                                            desiredStateHash: requestId,
-                                            toolCalls: [],
-                                            externalInteractions: [],
-                                            outcome: 'success',
-                                        };
-                                        evidenceHash = computeEvidenceSimHash(checkpoint);
-                                    }
-                                    catch (err) {
-                                        console.error(`[mech] Failed to compute evidence SimHash for ${requestId}:`, err);
-                                    }
-                                }
-                                await claimDelivery(this.publicClient, this.walletClient, this.config.safeAddress, this.config.routerAddress, requestId, { variant, evidenceHash });
-                            }
-                            catch (err) {
-                                const message = err instanceof Error ? err.message : String(err);
-                                if (message.includes('RequestNotFound')) {
-                                    console.error(`[mech] claimDelivery skipped (not a router request): ${requestId}`);
-                                    // fall through — creator actions below don't depend on our claim specifically
-                                }
-                                else if (/already.*claimed|alreadyClaimed/i.test(message)) {
-                                    // Idempotent: someone else raced us, fine.
-                                }
-                                else {
-                                    console.error(`[mech] claimDelivery failed for ${requestId}:`, err);
-                                    // Don't continue — may retry next poll via unchanged tracking
-                                    continue;
-                                }
-                            }
-                        }
-                        // (b) 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;
-                            try {
-                                const digest = deliveryDataHex.startsWith('0x') ? deliveryDataHex.slice(2) : deliveryDataHex;
-                                const payload = await fetchFromIpfs(this.config.ipfsGatewayUrl, `f01551220${digest}`);
-                                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);
+                        // (a) Deliverer-side claim path: if this Safe delivered the request,
+                        //     claim it first so router counters credit the deliverer.
+                        let deliveryClaimStatus;
+                        if (iDelivered) {
+                            deliveryClaimStatus = await this.ensureDeliveryClaimed(requestId, deliveryDataHex);
+                            if (deliveryClaimStatus === 'retry')
+                                continue;
                         }
-                        // (c) If I created the evaluation, clean up tracking once delivered.
-                        if (iCreatedEvaluation) {
-                            this.pendingEvaluationClaims.delete(requestId);
+                        // (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;
                         }
-                        // (d) 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}`);
@@ -353,31 +670,27 @@ export class MechAdapter {
                                 data: resultPayload.data ?? JSON.stringify(resultPayload),
                                 artifacts: resultPayload.artifacts,
                             };
-                            // Use the original desired state — not the result payload
-                            const desiredState = this.originalStates.get(requestId) ?? {
+                            // Use the original Task, not the result payload.
+                            const task = this.originalStates.get(requestId) ?? {
                                 id: requestId,
                                 description: '',
                             };
                             yield {
                                 requestId,
-                                desiredState,
+                                task,
                                 result: restorationResult,
                                 deliveryMechAddress: mechAddress,
                             };
                             // 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 desired state 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, {
@@ -395,126 +708,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 payload = (await fetchFromIpfs(this.config.ipfsGatewayUrl, `f01551220${dig}`));
-            const data = payload.data ?? JSON.stringify(payload);
-            this.pendingEvaluationResults.set(requestId, data);
-            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) {
-        if (!this.pendingEvaluations.has(requestId))
-            return;
-        const originalState = this.pendingEvaluations.get(requestId);
-        if (restorationResultData) {
-            this.pendingEvaluationResults.set(requestId, restorationResultData);
-            this.backfillMissRids.delete(requestId);
-        }
-        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;
-        }
-        try {
-            const evaluationState = {
-                ...originalState,
-                type: 'evaluation',
-                restorationRequestId: requestId,
-                context: {
-                    ...originalState.context,
-                    restorationResult: cachedRestorationResultData,
-                },
-            };
-            const evaluationPayload = buildDesiredStatePayload(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);
-            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, type: 'evaluation' });
-                }
-            }
-            // Success — clean up both tracking sets
-            this.pendingEvaluations.delete(requestId);
-            this.claimedButNotEvaluated.delete(requestId);
-            this.pendingEvaluationResults.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;
     }