@jinn-network/client 0.1.9 → 0.2.0-canary.0b79cd5d

package/dist/adapters/mech/adapter.js

@@ -1,4 +1,4 @@
-import { getAddress, zeroAddress } from 'viem';
+import { getAddress } from 'viem';
 import { keccak256, toBytes } from 'viem';
 import { privateKeyToAccount } from 'viem/accounts';
 import { base, baseSepolia } from 'viem/chains';
@@ -16,15 +16,37 @@ function rpcUrlForDisplay(rpcUrl) {
 import { buildResultPayload, uploadToIpfs, cidToDigestHex, fetchFromIpfs, fetchSignedTaskFromIpfs, fetchSignedEnvelopeFromIpfs, } from './ipfs.js';
 import { canonicalJson } from '../../harnesses/engine/canonical-json.js';
 import { normalizeEnvelopeRole, 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 { submitTask, claimTask as claimTaskOnchain, claimEvaluation as claimEvaluationOnchain, claimDelivery, getMechDeliveryRate, getTimeoutBounds, decodeTaskCreatedLogs, decodeSolutionDeliveryClaimedLogs, decodeDeliverLogs, ROUTER_DISCOVERY_EVENTS, MECH_DELIVER_EVENT, findLatestDeliveryDataHexForRequest, getMarketplaceRequestDeliveryMech, getTaskCidDigest, callDeliverToMarketplace, canClaimTask, canClaimEvaluation, } from './contracts.js';
 import { SafeInnerRevertError, formatDecodedRevert, isNonRecoverableInnerRevert, } from './safe-revert.js';
 import { VerdictCode, verdictCodeFromValue } from './verdict-code.js';
 import { manifestDigestForCid } from './digest.js';
+import { recordLoopTick } from '../../daemon/loop-heartbeat.js';
 import { emitStructured } from '../../events/emitter.js';
 import { withRecoverableRetry } from '../../tx-retry.js';
 import { formatRpcError } from '../../rpc-error-context.js';
 import { SOLUTION_ENVELOPE_CID_CONTEXT_KEY, SOLUTION_TASK_CID_CONTEXT_KEY, RESTORATION_TASK_CID_CONTEXT_KEY, } from '../../harnesses/impls/evaluation-context.js';
 import { signTaskV1 } from '../../tasks/signing.js';
+function taskCreationProvenanceFromSolutionEnvelope(value) {
+    if (typeof value !== 'object' || value === null)
+        return undefined;
+    const task = value['task'];
+    if (typeof task !== 'object' || task === null)
+        return undefined;
+    const record = task;
+    const tx = record['onchainCreationTx'];
+    const block = record['onchainCreationBlock'];
+    if (typeof tx !== 'string'
+        || !/^0x[0-9a-fA-F]{64}$/.test(tx)
+        || typeof block !== 'number'
+        || !Number.isSafeInteger(block)
+        || block < 0) {
+        return undefined;
+    }
+    return {
+        onchainCreationTx: tx,
+        onchainCreationBlock: block,
+    };
+}
 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;
@@ -153,6 +175,13 @@ export class MechAdapter {
      * its own attempt on a multi-attempt (`maxClaims > 1`) task it posted.
      */
     restorationBodyCache = new Map();
+    /**
+     * TaskCreated anchors observed directly from router logs (or our own
+     * confirmed createTask receipt). Evaluator envelopes are solver-controlled,
+     * so their embedded anchors are only claims until they match this chain
+     * source.
+     */
+    canonicalTaskCreationProvenance = new Map();
     requestKinds = new Map();
     evaluationOpportunities = new Map();
     pendingEvaluationSolutions = new Map();
@@ -164,6 +193,28 @@ export class MechAdapter {
         this.config = config;
         this.store = store;
     }
+    /**
+     * Whether this operator participates as an evaluator. Undefined ⇒ enabled
+     * (opt-out default). Gates evaluation-opportunity ingest, boot rehydrate, and
+     * per-cycle scan (#547).
+     */
+    get evaluatorEnabled() {
+        return this.config.evaluatorEnabled !== false;
+    }
+    /** Maps config pin → core `FetchFromIpfsOptions` (omit when unset = production ipfs.io). */
+    ipfsFetchOpts() {
+        const fallback = this.config.ipfsFallbackGatewayUrl;
+        if (fallback === undefined)
+            return undefined;
+        return { fallbackGatewayBase: fallback };
+    }
+    /**
+     * Enable the evaluator role at runtime after a live SolverNet join (a join
+     * never removes a role, so turning it back off is never needed). #547.
+     */
+    setEvaluatorEnabled(enabled) {
+        this.config.evaluatorEnabled = enabled;
+    }
     async initialize() {
         const chain = this.config.chainId === 84532 ? baseSepolia : base;
         const clients = createClients(this.config.rpcUrl, this.config.agentEoaPrivateKey, chain);
@@ -183,7 +234,13 @@ export class MechAdapter {
         this.deliveryBlockCursor = blockNumber;
         // Recover pending state from on-chain events
         if (this.store) {
-            this.loadPendingEvaluationSolutions();
+            // #547: only rehydrate the evaluation-opportunity set for evaluators.
+            // recoverPendingState recovers this operator's own in-flight restoration
+            // claims (router cursor + TaskCreated scan), not the evaluation set, so it
+            // stays unguarded.
+            if (this.evaluatorEnabled) {
+                this.loadPendingEvaluationSolutions();
+            }
             await this.recoverPendingState(blockNumber);
         }
         else {
@@ -278,8 +335,13 @@ export class MechAdapter {
             const end = start + DEFAULT_ROUTER_LOG_CHUNK_BLOCKS > toBlock
                 ? toBlock
                 : start + DEFAULT_ROUTER_LOG_CHUNK_BLOCKS;
+            // #116: filter server-side to the two router events the poll loop decodes
+            // (TaskCreated + SolutionDeliveryClaimed) via an OR-of-topic0, instead of an
+            // address-only scan that decode-discards the rest. Chunking is unchanged —
+            // a topic filter shrinks the result set, not the permitted block range.
             logs.push(...await this.publicClient.getLogs({
                 address: this.config.routerAddress,
+                events: ROUTER_DISCOVERY_EVENTS,
                 fromBlock: start,
                 toBlock: end,
             }));
@@ -441,7 +503,9 @@ export class MechAdapter {
         const restorationDataHex = cidToDigestHex(restorationCid);
         const digestNo0x = restorationDataHex.startsWith('0x') ? restorationDataHex.slice(2) : restorationDataHex;
         const restorationTaskCid = `f01551220${digestNo0x}`;
-        const deliveryRate = await getMechDeliveryRate(this.publicClient, this.config.mechContractAddress);
+        const baseDeliveryRate = await getMechDeliveryRate(this.publicClient, this.config.mechContractAddress);
+        const { resolveMintedTaskDeliveryRate } = await import('../../solver-types/_swe-rebench-v2-escrow.js');
+        const deliveryRate = resolveMintedTaskDeliveryRate(baseDeliveryRate, signedTask.eligibility);
         const { max: maxTimeout } = await getTimeoutBounds(this.publicClient, this.config.mechMarketplaceAddress);
         // Task 24 (spec/2026-05-05-solvernet-creation-and-launch.md §14): the
         // on-chain digest is now manifest-bound — `keccak256(manifestCid)` —
@@ -454,6 +518,13 @@ export class MechAdapter {
         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);
+        if (taskSubmission.txHash
+            && taskSubmission.blockNumber !== undefined) {
+            this.canonicalTaskCreationProvenance.set(taskSubmission.taskId, {
+                onchainCreationTx: taskSubmission.txHash,
+                onchainCreationBlock: taskSubmission.blockNumber,
+            });
+        }
         // Deliberately do NOT seed `observedTasks` with the task we just posted.
         // `observedTasks` is the dedup set for `watchForTasks`: the on-chain
         // TaskCreated scan skips any taskId already in it (so a task is announced
@@ -523,45 +594,25 @@ export class MechAdapter {
         return signTaskV1(taskDoc, this.config.agentEoaPrivateKey);
     }
     contractPolicyForTask(state) {
-        const nowSeconds = Math.floor(Date.now() / 1000);
+        // Tokenless-OLAS pivot: the on-chain TaskCoordinator.TaskPolicy is the
+        // launcher-funded attempt count (`maxClaims`) plus the self-evaluation gate
+        // (`allowSolverSelfEvaluation`). Windows, lease, and quorum do NOT cross the
+        // wire — that off-chain scheduling intent stays in the task.v1 `claimPolicy`
+        // field (still carried on the signed task document and read by the local
+        // scheduler).
+        //
+        // `allowSolverSelfEvaluation` comes from the off-chain `claimPolicy` when it
+        // sets the flag explicitly; that explicit value always wins. When it is
+        // absent (the common case — the auto-generators do not set it) the default
+        // is network-keyed: TRUE on testnet (Base Sepolia, 84532) so a single
+        // operator can solve + self-evaluate + close the loop solo for dogfooding,
+        // and FALSE on mainnet to preserve the independent-evaluation invariant (the
+        // coordinator rejects a verdict whose evaluator is the attempt's solver).
         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);
+        const isTestnet = this.config.chainId === 84532;
         return {
-            claimWindowStart,
-            claimWindowEnd,
-            submissionDeadline,
-            claimLeaseTtlSeconds: claimPolicy.claimLeaseTtlSeconds,
             maxClaims: claimPolicy.maxClaims,
-            maxClaimsPerOperator: claimPolicy.maxClaimsPerOperator,
-            policyHook: (claimPolicy.policyHook ?? zeroAddress),
-            evaluationPolicy: {
-                // `requiredVerdicts` defaults to 1 but is overridable via the task's
-                // claim policy. A value > 1 opens additional verdict claim slots per
-                // attempt; combined with the per-evaluator cap below (1), it
-                // guarantees an honest evaluator can still claim and deliver a slot
-                // even when other evaluators have squatted some — the structural fix
-                // for a shared/adversarial testnet where a non-delivering claimer
-                // would otherwise permanently lock a single-slot attempt.
-                requiredVerdicts: claimPolicy.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,
-            },
+            allowSolverSelfEvaluation: claimPolicy.allowSolverSelfEvaluation ?? isTestnet,
         };
     }
     buildEvaluationTask(params) {
@@ -591,7 +642,7 @@ export class MechAdapter {
         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 signed = await fetchSignedTaskFromIpfs(this.config.ipfsGatewayUrl, taskCid, this.ipfsFetchOpts());
         const task = parseTask({ signedTask: signed });
         const announcement = {
             taskId,
@@ -601,12 +652,45 @@ export class MechAdapter {
         this.restorationBodyCache.set(taskId, announcement);
         return announcement;
     }
+    rememberCanonicalTaskCreated(event) {
+        if (event.transactionHash === undefined
+            || !/^0x[0-9a-fA-F]{64}$/.test(event.transactionHash)
+            || event.blockNumber === undefined
+            || !Number.isSafeInteger(event.blockNumber)
+            || event.blockNumber < 0) {
+            return;
+        }
+        this.canonicalTaskCreationProvenance.set(event.taskId, {
+            onchainCreationTx: event.transactionHash,
+            onchainCreationBlock: event.blockNumber,
+        });
+    }
+    async canonicalTaskCreationForEvaluation(taskId, opportunityBlock) {
+        const cached = this.canonicalTaskCreationProvenance.get(taskId);
+        if (cached)
+            return cached;
+        const toBlock = opportunityBlock !== undefined
+            ? BigInt(opportunityBlock)
+            : await this.publicClient.getBlockNumber();
+        const fromBlock = this.taskAdmissionFloorBlock() ?? 0n;
+        if (fromBlock <= toBlock) {
+            const logs = await this.getRouterLogsInChunks(fromBlock, toBlock);
+            for (const event of decodeTaskCreatedLogs(logs)) {
+                this.rememberCanonicalTaskCreated(event);
+            }
+        }
+        const resolved = this.canonicalTaskCreationProvenance.get(taskId);
+        if (!resolved) {
+            throw new Error(`evaluation task ${taskId} has no canonical TaskCreated provenance in router logs`);
+        }
+        return resolved;
+    }
     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 signed = await fetchSignedTaskFromIpfs(this.config.ipfsGatewayUrl, taskCid, this.ipfsFetchOpts());
         const task = parseTask({ signedTask: signed });
         const announcement = {
             taskId: params.taskId,
@@ -618,6 +702,19 @@ export class MechAdapter {
         this.observedTasks.set(params.taskId, announcement);
         return announcement;
     }
+    /**
+     * #1412: a task's execution window (task.window.endTs) is only known after
+     * IPFS hydration, not from any on-chain/discovery candidate shape. The
+     * engine kills the harness subprocess the instant this window is in the
+     * past (engine.ts: setTimeout(abort, max(0, endTs - now)) fires at 0ms), so
+     * claiming an already-expired task always fails with no chance of a real
+     * solve. Both discovery paths (DiscoveryAPI and the on-chain TaskCreated
+     * backlog scan) must skip these before spending a claim tx on a doomed run.
+     */
+    hasExpiredExecutionWindow(announcement) {
+        const windowEndTs = announcement.task.window?.endTs;
+        return windowEndTs !== undefined && windowEndTs <= Date.now();
+    }
     async *discoverSubgraphRestorationTasks() {
         const discovery = this.config.taskDiscovery;
         const discoveryApi = discovery?.discoveryApi;
@@ -678,12 +775,15 @@ export class MechAdapter {
                 // cycle we let the engine apply its gate to each one, preserving the
                 // round-robin fairness across joined SolverNets. See task 212 live
                 // verification in the fix's commit body.
-                yield await this.restorationAnnouncementFromDigest({
+                const announcement = await this.restorationAnnouncementFromDigest({
                     taskId: candidate.taskId,
                     taskCidDigest: candidate.taskCidDigest,
                     transactionHash: candidate.createdAtTx,
                     blockNumber: candidate.createdAtBlock,
                 });
+                if (this.hasExpiredExecutionWindow(announcement))
+                    continue;
+                yield announcement;
             }
             catch (err) {
                 console.error(`[mech] failed to hydrate subgraph task ${candidate.taskId}:`, err instanceof Error ? err.message : err);
@@ -759,7 +859,28 @@ export class MechAdapter {
             });
             return undefined;
         }
-        const resultPayload = await fetchFromIpfs(this.config.ipfsGatewayUrl, solutionEnvelopeCid);
+        const resultPayload = await fetchFromIpfs(this.config.ipfsGatewayUrl, solutionEnvelopeCid, this.ipfsFetchOpts());
+        let creationProvenance = taskCreationProvenanceFromSolutionEnvelope(resultPayload);
+        if (!creationProvenance && typeof resultPayload.data === 'string') {
+            try {
+                creationProvenance = taskCreationProvenanceFromSolutionEnvelope(JSON.parse(resultPayload.data));
+            }
+            catch {
+                // Legacy non-envelope result payload. The fail-closed check below
+                // keeps it out of the new provenance-bearing writer path.
+            }
+        }
+        if (!creationProvenance) {
+            throw new Error(`evaluation opportunity ${solution.requestId} is missing canonical TaskCreated provenance in its solution envelope`);
+        }
+        const canonicalCreationProvenance = await this.canonicalTaskCreationForEvaluation(solution.taskId, solution.blockNumber);
+        if (creationProvenance.onchainCreationTx.toLowerCase()
+            !== canonicalCreationProvenance.onchainCreationTx.toLowerCase()
+            || creationProvenance.onchainCreationBlock
+                !== canonicalCreationProvenance.onchainCreationBlock) {
+            throw new Error(`evaluation opportunity ${solution.requestId} solution-envelope provenance `
+                + `does not match canonical TaskCreated provenance for task ${solution.taskId}`);
+        }
         const resultData = resultPayload.data ?? JSON.stringify(resultPayload);
         const evaluationTask = this.buildEvaluationTask({
             task: restoration.task,
@@ -774,13 +895,17 @@ export class MechAdapter {
             taskId: opportunityId,
             task: evaluationTask,
             taskCid: restoration.taskCid,
-            onchainCreationTx: solution.transactionHash,
-            onchainCreationBlock: solution.blockNumber,
+            onchainCreationTx: canonicalCreationProvenance.onchainCreationTx,
+            onchainCreationBlock: canonicalCreationProvenance.onchainCreationBlock,
+            onchainOpportunityTx: solution.transactionHash,
+            onchainOpportunityBlock: solution.blockNumber,
         };
         this.evaluationOpportunities.set(opportunityId, {
             taskId: solution.taskId,
             attemptIndex: solution.attemptIndex,
             task: evaluationTask,
+            onchainCreationTx: canonicalCreationProvenance.onchainCreationTx,
+            onchainCreationBlock: canonicalCreationProvenance.onchainCreationBlock,
         });
         this.observedTasks.set(opportunityId, announcement);
         // #645: a successful announcement means the candidate has made progress;
@@ -794,6 +919,8 @@ export class MechAdapter {
         return announcement;
     }
     async *retryPendingEvaluationSolutions() {
+        if (!this.evaluatorEnabled)
+            return; // #547: non-evaluators never scan.
         let processed = 0;
         for (const [requestId, solution] of Array.from(this.pendingEvaluationSolutions)) {
             // Yield to the event loop periodically so a large backlog of pending
@@ -832,16 +959,19 @@ export class MechAdapter {
                 if (currentBlock > this.requestBlockCursor) {
                     const fromBlock = this.requestBlockCursor + 1n;
                     const logs = await this.getRouterLogsInChunks(fromBlock, currentBlock);
-                    const submittedSolutions = decodeSolutionDeliveryClaimedLogs(logs);
-                    for (const solution of submittedSolutions) {
-                        this.rememberPendingEvaluationSolution(solution);
-                    }
-                    this.requestBlockCursor = currentBlock;
-                    if (this.store) {
-                        this.store.setConfigValue(ROUTER_REQUEST_CURSOR_CONFIG_KEY, currentBlock.toString());
+                    // #547: only evaluators ingest delivery-claimed logs into the
+                    // pending-evaluation set. Restoration discovery below is unaffected.
+                    if (this.evaluatorEnabled) {
+                        const submittedSolutions = decodeSolutionDeliveryClaimedLogs(logs);
+                        for (const solution of submittedSolutions) {
+                            this.rememberPendingEvaluationSolution(solution);
+                        }
                     }
                     const joinedManifestDigests = this.joinedManifestDigestSet();
                     const createdTasks = decodeTaskCreatedLogs(logs);
+                    for (const event of createdTasks) {
+                        this.rememberCanonicalTaskCreated(event);
+                    }
                     for (const { taskId, taskCidDigest, manifestDigest, transactionHash, blockNumber } of createdTasks) {
                         if (!this.isDiscoveryTaskAllowed(taskId))
                             continue;
@@ -859,6 +989,8 @@ export class MechAdapter {
                                 transactionHash,
                                 blockNumber,
                             });
+                            if (this.hasExpiredExecutionWindow(announcement))
+                                continue;
                             yield announcement;
                         }
                         catch (err) {
@@ -868,6 +1000,10 @@ export class MechAdapter {
                     for await (const announcement of this.retryPendingEvaluationSolutions()) {
                         yield announcement;
                     }
+                    this.requestBlockCursor = currentBlock;
+                    if (this.store) {
+                        this.store.setConfigValue(ROUTER_REQUEST_CURSOR_CONFIG_KEY, currentBlock.toString());
+                    }
                 }
             }
             catch (err) {
@@ -879,6 +1015,10 @@ export class MechAdapter {
                     fromBlock: this.requestBlockCursor + 1n,
                 }));
             }
+            // #1043/#1038: heartbeat at the poll-cycle tail (every poll, even when
+            // nothing was yielded) so an idle-but-polling loop never looks stale.
+            if (this.store)
+                recordLoopTick(this.store, 'engine-watcher');
             await new Promise(r => setTimeout(r, this.config.pollIntervalMs));
         }
     }
@@ -903,8 +1043,10 @@ export class MechAdapter {
                 attemptIndex: claimed.attemptIndex,
                 task: evaluationOpportunity.task,
                 taskCid: evaluationCid,
-                onchainCreationTx: claimed.txHash,
-                onchainCreationBlock: claimed.blockNumber,
+                onchainCreationTx: evaluationOpportunity.onchainCreationTx,
+                onchainCreationBlock: evaluationOpportunity.onchainCreationBlock,
+                onchainClaimTx: claimed.txHash,
+                onchainClaimBlock: claimed.blockNumber,
             };
         }
         const announcement = this.observedTasks.get(taskId);
@@ -922,8 +1064,10 @@ export class MechAdapter {
             attemptIndex: claimed.attemptIndex,
             task,
             taskCid: announcement.taskCid,
-            onchainCreationTx: claimed.txHash,
-            onchainCreationBlock: claimed.blockNumber,
+            onchainCreationTx: announcement.onchainCreationTx,
+            onchainCreationBlock: announcement.onchainCreationBlock,
+            onchainClaimTx: claimed.txHash,
+            onchainClaimBlock: claimed.blockNumber,
         };
     }
     async submitResult(requestId, result) {
@@ -956,7 +1100,7 @@ export class MechAdapter {
             ? deliveryDataHex.slice(2)
             : deliveryDataHex;
         const envelopeCid = `f01551220${deliveryDigest}`;
-        const rawEnvelope = await fetchSignedEnvelopeFromIpfs(this.config.ipfsGatewayUrl, envelopeCid);
+        const rawEnvelope = await fetchSignedEnvelopeFromIpfs(this.config.ipfsGatewayUrl, envelopeCid, this.ipfsFetchOpts());
         const parsed = SignedEnvelopeSchema.parse(rawEnvelope);
         const rawSigned = rawEnvelope;
         const { signature: _rawSignature, ...unsignedBody } = rawSigned;
@@ -1059,8 +1203,11 @@ export class MechAdapter {
             const chunkEnd = chunkStart + DEFAULT_ROUTER_LOG_CHUNK_BLOCKS > currentBlock
                 ? currentBlock
                 : chunkStart + DEFAULT_ROUTER_LOG_CHUNK_BLOCKS;
+            // #116: pin the mech `Deliver` topic server-side rather than fetching the
+            // whole address and decode-discarding. Range/chunking unchanged.
             const logs = await this.publicClient.getLogs({
                 address: this.config.mechContractAddress,
+                event: MECH_DELIVER_EVENT,
                 fromBlock: chunkStart,
                 toBlock: chunkEnd,
             });
@@ -1136,7 +1283,7 @@ export class MechAdapter {
                         // (c) Yield the delivery result.
                         try {
                             const deliveryDigest = deliveryDataHex.startsWith('0x') ? deliveryDataHex.slice(2) : deliveryDataHex;
-                            const resultPayload = await fetchFromIpfs(this.config.ipfsGatewayUrl, `f01551220${deliveryDigest}`);
+                            const resultPayload = await fetchFromIpfs(this.config.ipfsGatewayUrl, `f01551220${deliveryDigest}`, this.ipfsFetchOpts());
                             const restorationResult = {
                                 data: resultPayload.data ?? JSON.stringify(resultPayload),
                                 artifacts: resultPayload.artifacts,
@@ -1172,6 +1319,10 @@ export class MechAdapter {
             }
             // Cursor persistence is per-chunk inside the loop above (#552). A poll
             // that did no chunked work has no progress to persist.
+            // #1043/#1038: heartbeat at the poll-cycle tail (every poll, even when
+            // nothing was yielded) so an idle-but-polling loop never looks stale.
+            if (this.store)
+                recordLoopTick(this.store, 'delivery-watcher');
             await new Promise(r => setTimeout(r, this.config.pollIntervalMs));
         }
     }