@jinn-network/client 0.1.8 → 0.1.9-canary.023faefb

package/CONTRIBUTING.md

@@ -74,7 +74,7 @@ The `files` field in `package.json` ensures only `dist/`, `deployments/`, `READM
 
 ## Releases
 
-Use [RELEASING.md](./RELEASING.md) for the package bootstrap publish, npm trusted-publishing setup, canary/stable release flow, the fork-based operator gate (`yarn release:operator-gate`), the cross-operator donation consumption gate (`yarn release:donation-consumption`), the contracts release gate (`cd ../contracts && yarn test && forge install foundry-rs/forge-std --no-git && forge test --match-contract Invariant`), and the manual Docker-first real testnet acceptance gate (`yarn release:testnet-acceptance`) that must pass on the exact stable release commit. The dedicated Docker acceptance environment and evidence expectations are documented in [TESTNET_ACCEPTANCE.md](./TESTNET_ACCEPTANCE.md).
+Use [RELEASING.md](./RELEASING.md) for the package bootstrap publish, npm trusted-publishing setup, canary/stable release flow, the fork-based operator gate (`yarn release:operator-gate`), the OLAS rails smoke gate (`yarn release:olas-rails-smoke`), the contracts release gate (`cd ../contracts && yarn test && forge install foundry-rs/forge-std --no-git && forge test --match-contract Invariant`), and the manual Docker-first real testnet acceptance gate (`yarn release:testnet-acceptance`) that must pass on the exact stable release commit. The dedicated Docker acceptance environment and evidence expectations are documented in [TESTNET_ACCEPTANCE.md](./TESTNET_ACCEPTANCE.md).
 
 ## Updating deployment artifacts
 
@@ -98,7 +98,7 @@ This copies the 4 deployment JSON files from `contracts/` into `client/deploymen
 | `yarn staking` | Earning bootstrap validation on Anvil fork |
 | `yarn pack:smoke` | Pack tarball and run smoke tests |
 | `yarn release:operator-gate` | Run the stable-release operator gate (`staking` then `e2e`) |
-| `yarn release:donation-consumption` | Prove two isolated operators can consume donated SWE execution data through real testnet on-chain/IPFS/MCP paths |
+| `yarn release:olas-rails-smoke` | Dry-run by default: writes a prediction.v1 smoke spec and evidence plan; pass `--execute` for live Base Sepolia OLAS rails proof |
 | `cd ../contracts && yarn test && forge install foundry-rs/forge-std --no-git && forge test --match-contract Invariant` | Run the contracts release gate |
 | `yarn release:testnet-acceptance` | Run the manual Docker-first real testnet acceptance harness |
 | `yarn setup:testnet-acceptance-operator` | First-time Docker acceptance setup + bootstrap/funding helper (`TESTNET_ACCEPTANCE.md`) |

package/README.md

@@ -184,6 +184,12 @@ returns `waiting_for_external_action` with the URL and the exact command to
 rerun next. Agents with the `jinn-operator` skill installed know how to walk an
 operator through a SolverNet automatically.
 
+Each Harness reads its **own** auth store (the daemon only forwards an
+allowlisted set of env vars — it does not hold your provider keys). For the
+per-harness auth store, the canonical rotate command/file, and why `client/.env`
+must not be used to set provider keys at runtime, see
+[`docs/operator/rotating-harness-keys.md`](../docs/operator/rotating-harness-keys.md).
+
 **Safety net:** before spending gas on a claim, the daemon checks whether the
 responsible Harness is actually ready. If a portfolio.v0 request arrives and your
 api-wallet isn't approved, the daemon records the Task as FAILED locally

package/deployments/deployment-phase1b-mech-baseSepolia-fast.json

@@ -2,7 +2,7 @@
   "network": "baseSepolia",
   "chainId": 84532,
   "deployer": "0x15e78734481bD31F6e183dad05225505a45ACd07",
-  "deployedAt": "2026-04-09T13:21:20.747Z",
+  "deployedAt": "2026-06-30T16:18:56.618Z",
   "config": {
     "timingProfile": "fast-test",
     "fee": 0,
@@ -18,9 +18,9 @@
     "mechMarketplace": "0xD3233FdAaB51E9775f6bFCE8242B02C181D7c0e7",
     "balanceTracker": "0xDbeEF1947F7BB3657f984aA6b230a0ca6578229D",
     "mechFactory": "0x206183F35B2450Ca15A906BB923E74d945F78d67",
-    "jinnRouter": "0x13dae57a54A7DF862113BcA8Ee2fd3dEf6a6A94A",
+    "jinnRouter": "0x6059Dd37eB0FD3a55BCe7A3C1fA86AB84F2d9675",
     "serviceRegistry": "0x31D3202d8744B16A120117A053459DDFAE93c855",
     "activityChecker": "0x0e1B5f264F4FAdcFAA950fb00c58d9A39C040f70",
-    "stakingToken": "0x24e34E5037956a5Feca1AAAfaA30297084C228B8"
+    "stakingToken": "0x4DB0Fcb877CCd92B6AeEdAaD561DaccB0CCc7E39"
   }
 }

package/deployments/deployment-stolas-l2-baseSepolia-fast.json

@@ -2,10 +2,10 @@
   "network": "baseSepolia",
   "chainId": 84532,
   "deployer": "0x15e78734481bD31F6e183dad05225505a45ACd07",
-  "deployedAt": "2026-04-10T16:46:00.888Z",
+  "deployedAt": "2026-06-30T16:18:56.618Z",
   "config": {
     "l2Jinn": "0xAB9a01cd4A379e36006ec6df2960CF39EF79df63",
-    "stakingContract": "0xf358b5c1ac4ddc4e807b5baf008826bf193eab3b",
+    "stakingContract": "0x4DB0Fcb877CCd92B6AeEdAaD561DaccB0CCc7E39",
     "l1DepositProcessor": "0x494FBcd686C895fD6265e852086B53Abf15cb076",
     "l1DistributorProxy": "0x12F14eF5b4881a932BE3F334599cB9473aBE987A",
     "l1TreasuryProxy": "0xa87c117cB54d9C6C8a8e0aA0b336a1125E485Cb7",
@@ -31,5 +31,25 @@
     "stakingManagerImpl": "0xFb0B086D3f7C03f1F671C6ccD5D16CC779B25Af9",
     "stakingManager": "0x5edCd012C581b946E06a74e1906a5f29D588403e",
     "baseStakingProcessorL2": "0x23a063f600e9938405D0367a137f1bE2F0B4D0D2"
-  }
+  },
+  "rewires": [
+    {
+      "rewiredAt": "2026-06-29T14:53:46.226Z",
+      "deployer": "0x15e78734481bD31F6e183dad05225505a45ACd07",
+      "legacyStakingProxy": "0xf358b5c1ac4ddc4e807b5baf008826bf193eab3b",
+      "freshStakingProxy": "0x3A14c71e94F3d38A6BE4319808B259FbFb47B86f",
+      "activityChecker": "0x0e1B5f264F4FAdcFAA950fb00c58d9A39C040f70",
+      "packedConfig": "2199023257600001",
+      "fundWei": "100000000000000000000"
+    },
+    {
+      "rewiredAt": "2026-06-30T16:18:56.618Z",
+      "deployer": "0x15e78734481bD31F6e183dad05225505a45ACd07",
+      "legacyStakingProxy": "0x3A14c71e94F3d38A6BE4319808B259FbFb47B86f",
+      "freshStakingProxy": "0x4DB0Fcb877CCd92B6AeEdAaD561DaccB0CCc7E39",
+      "activityChecker": "0x0e1B5f264F4FAdcFAA950fb00c58d9A39C040f70",
+      "packedConfig": "2199023257600001",
+      "fundWei": "100000000000000000000"
+    }
+  ]
 }

package/deployments/deployment-task-coordinator-router-v3-baseSepolia-fast.json

@@ -3,7 +3,7 @@
   "chainId": 84532,
   "deployer": "0x15e78734481bD31F6e183dad05225505a45ACd07",
   "owner": "0x15e78734481bD31F6e183dad05225505a45ACd07",
-  "deployedAt": "2026-05-02T12:27:26.420Z",
+  "deployedAt": "2026-06-29T14:52:46.003Z",
   "config": {
     "timingProfile": "fast-test",
     "mechMarketplaceSource": "deployment-phase1b-mech-baseSepolia-fast.json",
@@ -11,13 +11,13 @@
     "coordinatorInitialOwner": "0x15e78734481bD31F6e183dad05225505a45ACd07"
   },
   "contracts": {
-    "taskCoordinatorImpl": "0x830bFdBdA48D599e414c51888c8CDA6c84e67B18",
-    "taskCoordinator": "0x9ce736d3CB367cC5Db538B7962bdf416EbD7451B",
-    "jinnRouterV3Impl": "0x5f3E1e26Fd26b7A6BE4171976e555d62Bd3dcFC0",
-    "jinnRouterV3": "0xdC9BCcEB7aca21Ad4Ca2Fc5B4d7aea6b4F6CedD9",
+    "taskCoordinatorImpl": "0xC756D4A5b7a6a7C2F74Fa4Ce4fd84E7b82D223ca",
+    "taskCoordinator": "0x8a34793e10595c89B7e41Cc7Ff0F76850F44AD98",
+    "jinnRouterV3Impl": "0x2521e932B2508B2589cCc35F8cfB8B29f0e086D5",
+    "jinnRouterV3": "0x6f47863Ac4120A5a97Af224a5e30C3Ec2c9eA247",
     "mechMarketplace": "0xD3233FdAaB51E9775f6bFCE8242B02C181D7c0e7",
     "activityChecker": "0x0e1B5f264F4FAdcFAA950fb00c58d9A39C040f70",
-    "activityCheckerImpl": "0x9e573CFbbc52729528199005A9F3d274FE7052C4"
+    "activityCheckerImpl": "0x3f061273348264b2a1Ae584eCC614185748832a8"
   },
   "upgrades": [
     {
@@ -33,6 +33,34 @@
         "jinnRouterV3Impl": "0x5f3E1e26Fd26b7A6BE4171976e555d62Bd3dcFC0",
         "activityCheckerImpl": "0x9e573CFbbc52729528199005A9F3d274FE7052C4"
       }
+    },
+    {
+      "upgradedAt": "2026-05-06T13:41:14.651Z",
+      "deployer": "0x15e78734481bD31F6e183dad05225505a45ACd07",
+      "previous": {
+        "taskCoordinatorImpl": "0x830bFdBdA48D599e414c51888c8CDA6c84e67B18",
+        "jinnRouterV3Impl": "0x5f3E1e26Fd26b7A6BE4171976e555d62Bd3dcFC0",
+        "activityCheckerImpl": "0x9e573CFbbc52729528199005A9F3d274FE7052C4"
+      },
+      "current": {
+        "taskCoordinatorImpl": "0x047C9d27acD5cd860398389f48b87d42BEaCd8fd",
+        "jinnRouterV3Impl": "0xDb713EB5F1827C5764e7B0E4c7d8951BeD2ba0ee",
+        "activityCheckerImpl": "0x84E0302460Ab11B2169a2D00336C049Ab650a4aC"
+      }
+    },
+    {
+      "upgradedAt": "2026-06-29T14:52:46.003Z",
+      "deployer": "0x15e78734481bD31F6e183dad05225505a45ACd07",
+      "previous": {
+        "taskCoordinatorImpl": "0x047C9d27acD5cd860398389f48b87d42BEaCd8fd",
+        "jinnRouterV3Impl": "0xDb713EB5F1827C5764e7B0E4c7d8951BeD2ba0ee",
+        "activityCheckerImpl": "0x84E0302460Ab11B2169a2D00336C049Ab650a4aC"
+      },
+      "current": {
+        "taskCoordinatorImpl": "0x69f857b222D970460202e9C94c6205Be87582610",
+        "jinnRouterV3Impl": "0x7c1F768E92c7Fd84e789CB7748B70340B876E25d",
+        "activityCheckerImpl": "0x916027798716518a601824ea1A6f09105a152C36"
+      }
     }
   ]
 }

package/dist/adapters/mech/adapter.d.ts

@@ -52,7 +52,26 @@ export declare class MechAdapter implements ExecutionAdapter {
     constructor(config: MechAdapterConfig, store?: Store);
     initialize(): Promise<void>;
     private recoverPendingState;
-    private onchainTaskDiscoveryFromBlock;
+    /**
+     * The gh #300 scorability admission floor: tasks created before this block are
+     * "ghosts" from a prior eval-semantics regime and are rejected — including on
+     * the `DiscoveryAPI` (indexer) path. Fixed per chain; an explicit operator
+     * `onchainFromBlock` raises it. Returns `undefined` when no SolverNet is joined
+     * (the daemon claims nothing, so there is no floor to apply).
+     *
+     * This is deliberately NOT the on-chain scan start — see `onchainScanFromBlock`.
+     * Bounding the scan for RPC cost must never narrow which tasks are admitted.
+     */
+    private taskAdmissionFloorBlock;
+    /**
+     * Start block for the on-chain TaskCreated backlog scan (the secondary backstop
+     * behind `DiscoveryAPI.findClaimableTasks`). Defaults to a bounded rolling
+     * window `head − DEFAULT_ONCHAIN_SCAN_WINDOW_BLOCKS`, never below the admission
+     * floor (scanning pre-floor blocks only surfaces rejected ghosts). An explicit
+     * `onchainFromBlock` override pins an absolute start, honored as the operator's
+     * choice. Returns `undefined` when no SolverNet is joined.
+     */
+    private onchainScanFromBlock;
     private joinedManifestDigestSet;
     private allowedDiscoveryTaskIds;
     private isDiscoveryTaskAllowed;
@@ -89,6 +108,16 @@ export declare class MechAdapter implements ExecutionAdapter {
     private buildEvaluationTask;
     private restorationAnnouncementForTaskId;
     private restorationAnnouncementFromDigest;
+    /**
+     * #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.
+     */
+    private hasExpiredExecutionWindow;
     private discoverSubgraphRestorationTasks;
     /**
      * Look up the Deliver-event envelope CID for a pending evaluation solution.
@@ -118,6 +147,7 @@ export declare class MechAdapter implements ExecutionAdapter {
     submitSolutionDelivery(requestId: RequestId, solutionDigest: Hex): Promise<void>;
     submitVerdictDelivery(requestId: RequestId, verdictDigest: Hex, verdictCode: VerdictCode): Promise<void>;
     private deliveryClaimForDelivery;
+    private verdictCodeFromEnvelopePayload;
     private ensureDeliveryClaimed;
     /**
      * Paginate `getLogs` over `[deliveryBlockCursor+1, currentBlock]` chunked by

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,10 +16,11 @@ 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 { verdictCodeFromValue } from './verdict-code.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';
@@ -64,6 +65,20 @@ function isTerminalEvaluationReason(revertName) {
     return isNonRecoverableInnerRevert(revertName);
 }
 const DEFAULT_ROUTER_LOG_CHUNK_BLOCKS = 9999n;
+/**
+ * Default rolling-window size for the on-chain TaskCreated backlog scan (#801).
+ *
+ * The scan is a *backstop* behind `DiscoveryAPI.findClaimableTasks` (the indexer
+ * on testnet, the newest-first RPC floor on mainnet), which is the primary
+ * discovery path on every chain. Without a bound the scan replays from the fixed
+ * admission floor to head on *every* restart, a range that grows monotonically
+ * with the chain — the startup-stall regression #801 documents. Bounding it to
+ * `head − N` makes restart cost fixed regardless of chain age while still
+ * re-observing a generous recent window (~28h on Base at ~2s/block) for tasks
+ * and SolutionDeliveryClaimed events the indexer might have lagged on. Operators
+ * who want a wider net pin an absolute start via `taskDiscoveryOnchainFromBlock`.
+ */
+const DEFAULT_ONCHAIN_SCAN_WINDOW_BLOCKS = 50000n;
 /**
  * Floor block for the on-chain TaskCreated backlog scan, per chain.
  *
@@ -173,7 +188,7 @@ export class MechAdapter {
             await this.recoverPendingState(blockNumber);
         }
         else {
-            const fromBlock = this.onchainTaskDiscoveryFromBlock();
+            const fromBlock = this.onchainScanFromBlock(blockNumber);
             if (fromBlock && fromBlock <= blockNumber) {
                 this.requestBlockCursor = fromBlock - 1n;
             }
@@ -193,17 +208,27 @@ export class MechAdapter {
         if (routerFromBlock < currentBlock) {
             this.requestBlockCursor = routerFromBlock;
         }
-        const scanFromBlock = this.onchainTaskDiscoveryFromBlock();
+        const scanFromBlock = this.onchainScanFromBlock(currentBlock);
         if (scanFromBlock && scanFromBlock <= currentBlock) {
             const canonicalCursor = scanFromBlock - 1n;
             if (canonicalCursor < this.requestBlockCursor) {
                 this.requestBlockCursor = canonicalCursor;
             }
-            console.error(`[mech] TaskCreated canonical backlog scan enabled from block ${scanFromBlock}; ` +
-                'subgraph discovery is optional acceleration only');
+            console.error(`[mech] TaskCreated backlog scan (bounded backstop) enabled from block ${scanFromBlock}; ` +
+                'DiscoveryAPI.findClaimableTasks is the primary discovery path');
         }
     }
-    onchainTaskDiscoveryFromBlock() {
+    /**
+     * The gh #300 scorability admission floor: tasks created before this block are
+     * "ghosts" from a prior eval-semantics regime and are rejected — including on
+     * the `DiscoveryAPI` (indexer) path. Fixed per chain; an explicit operator
+     * `onchainFromBlock` raises it. Returns `undefined` when no SolverNet is joined
+     * (the daemon claims nothing, so there is no floor to apply).
+     *
+     * This is deliberately NOT the on-chain scan start — see `onchainScanFromBlock`.
+     * Bounding the scan for RPC cost must never narrow which tasks are admitted.
+     */
+    taskAdmissionFloorBlock() {
         const discovery = this.config.taskDiscovery;
         const hasJoinedSolverNet = (discovery?.solverNetManifestCids?.length ?? 0) > 0;
         if (!hasJoinedSolverNet)
@@ -215,6 +240,24 @@ export class MechAdapter {
         }
         return DEFAULT_TASK_DISCOVERY_FROM_BLOCK[this.config.chainId];
     }
+    /**
+     * Start block for the on-chain TaskCreated backlog scan (the secondary backstop
+     * behind `DiscoveryAPI.findClaimableTasks`). Defaults to a bounded rolling
+     * window `head − DEFAULT_ONCHAIN_SCAN_WINDOW_BLOCKS`, never below the admission
+     * floor (scanning pre-floor blocks only surfaces rejected ghosts). An explicit
+     * `onchainFromBlock` override pins an absolute start, honored as the operator's
+     * choice. Returns `undefined` when no SolverNet is joined.
+     */
+    onchainScanFromBlock(head) {
+        const floor = this.taskAdmissionFloorBlock();
+        if (floor === undefined)
+            return undefined;
+        // An explicit override is reflected verbatim in `floor`; honor it as the pin.
+        if (this.config.taskDiscovery?.onchainFromBlock !== undefined)
+            return floor;
+        const window = head - DEFAULT_ONCHAIN_SCAN_WINDOW_BLOCKS;
+        return window > floor ? window : floor;
+    }
     joinedManifestDigestSet() {
         const cids = this.config.taskDiscovery?.solverNetManifestCids ?? [];
         return new Set(cids
@@ -236,8 +279,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,
             }));
@@ -481,45 +529,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) {
@@ -576,6 +604,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;
@@ -598,7 +639,7 @@ export class MechAdapter {
             console.error('[mech] task discovery (DiscoveryAPI) failed:', err instanceof Error ? err.message : err);
             return;
         }
-        const discoveryFloorBlock = this.onchainTaskDiscoveryFromBlock();
+        const discoveryFloorBlock = this.taskAdmissionFloorBlock();
         for (const candidate of candidates) {
             if (!this.isDiscoveryTaskAllowed(candidate.taskId))
                 continue;
@@ -636,12 +677,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);
@@ -794,10 +838,6 @@ export class MechAdapter {
                     for (const solution of submittedSolutions) {
                         this.rememberPendingEvaluationSolution(solution);
                     }
-                    this.requestBlockCursor = currentBlock;
-                    if (this.store) {
-                        this.store.setConfigValue(ROUTER_REQUEST_CURSOR_CONFIG_KEY, currentBlock.toString());
-                    }
                     const joinedManifestDigests = this.joinedManifestDigestSet();
                     const createdTasks = decodeTaskCreatedLogs(logs);
                     for (const { taskId, taskCidDigest, manifestDigest, transactionHash, blockNumber } of createdTasks) {
@@ -817,6 +857,8 @@ export class MechAdapter {
                                 transactionHash,
                                 blockNumber,
                             });
+                            if (this.hasExpiredExecutionWindow(announcement))
+                                continue;
                             yield announcement;
                         }
                         catch (err) {
@@ -826,6 +868,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) {
@@ -837,6 +883,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));
         }
     }
@@ -930,15 +980,31 @@ export class MechAdapter {
         }
         const kind = role === 'verdict' ? 'verdict' : 'solution';
         const payload = rawSigned['payload'];
-        const rawVerdict = payload != null && typeof payload === 'object'
-            ? payload['verdict']
+        const verdictCode = kind === 'verdict'
+            ? this.verdictCodeFromEnvelopePayload(parsed.solverType, payload)
             : undefined;
         return {
             evidenceHash: recomputed,
             kind,
-            verdictCode: kind === 'verdict' ? verdictCodeFromValue(rawVerdict) : undefined,
+            verdictCode,
         };
     }
+    verdictCodeFromEnvelopePayload(solverType, payload) {
+        if (payload == null || typeof payload !== 'object') {
+            throw new Error(`missing verdict payload for solverType=${solverType}; refusing to claim Invalid(3) without an explicit evaluator verdict`);
+        }
+        const record = payload;
+        const rawVerdict = record['verdict'];
+        if (rawVerdict !== undefined)
+            return verdictCodeFromValue(rawVerdict);
+        if (solverType === 'swe-rebench-v2.v1') {
+            const passedMatch = record['passed_match'];
+            if (typeof passedMatch === 'boolean') {
+                return passedMatch ? VerdictCode.Pass : VerdictCode.Fail;
+            }
+        }
+        throw new Error(`missing verdict signal for solverType=${solverType}; refusing to claim Invalid(3) without an explicit evaluator verdict`);
+    }
     async ensureDeliveryClaimed(requestId, deliveryDataHex) {
         let claimOptions;
         try {
@@ -1001,8 +1067,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,
             });
@@ -1114,6 +1183,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));
         }
     }