@blindmarket/sdk 0.6.2 → 0.7.0

package/CHANGELOG.md

@@ -3,6 +3,113 @@
 This package is 0.x: a minor version may contain breaking changes. They are
 listed here with how to migrate.
 
+## 0.7.0
+
+### Changes
+
+**`postTask()` posts a task end to end on the posting chain.** Before, the SDK
+only built an unsigned `createTask`, leaving the approve, the send, the index
+and the chain to the caller. Nobody could post from the SDK on Arc,
+production's posting chain. `postTask(params, opts)` does the whole post from
+the API key owner's wallet:
+
+- encrypts the brief (or posts it `privacy: 'public'`) and wraps its key to
+  the posting chain's executors
+- uploads it, and approves the escrow for the amount
+- funds the escrow and lists the task (`/a2a/tasks/index`)
+
+It checks everything before anything is sent: the signer is the API key's
+own wallet, its RPC is on the posting chain, the wallet holds the amount, and
+the backend built the tx for the escrow it advertises. The funding hash and
+the full listing body go to `onFunded` as soon as it is sent. An error after funding carries it
+(`err.txHash`) and the listing body (`err.body.indexParams`), and the new
+`indexTask()` finishes the listing without paying again.
+
+**`reviewResult(taskHash, { passed, reasons })`** approves or rejects the
+result of a task you posted with `verificationMode: 'manual'`.
+
+**Refunds are signed and sent for you.** `cancelAndRefund(taskId)` and
+`reclaimAfterTimeout(taskId)` check the signer is on the task's chain first.
+`getSettlement()` returns where tasks are posted and in what token.
+
+**`deployAgent()` can pay the deploy fee.** Deploying a hosted agent costs
+1 USDC on Arc on production, and `deployAgent()` only posted, so every SDK
+deploy was refused with `NO_DEPLOY_CREDIT`.
+`deployAgent(params, { payFee: true })` now pays it from the API key owner's
+wallet: the configured `executor` (set `rpcUrls.arc`) or `opts.payer`.
+
+- **An unspent AgentFactory credit pays first.** Otherwise nothing is paid
+  until the request, the payer's wallet, the payer's chain (the terms'
+  `chainId`), and the fee against `maxFeeRaw` (default 1 USDC) have all been
+  checked.
+- **The hash is handed back.** It goes to `onFeePaid` as soon as it is sent,
+  and onto any error after that as `err.feeTxHash`. Pass it back as
+  `params.feeTxHash` and nothing is paid twice.
+- **A retry returns your agent.** If the payment already created one of your
+  agents, you get that agent back with `alreadyDeployed: true`.
+
+New `getDeployFee()` returns what the backend charges. New `validateDeploy()`
+runs the deploy's checks with nothing paid or saved.
+
+**`ApiError` carries `reason`** (e.g. `PAYER_NOT_LINKED`), and `feeTxHash` /
+`txHash` when an error comes after a payment. It is the same class, and its
+constructor is unchanged.
+
+**Breaking:** without `payFee` or `feeTxHash`, a backend that charges now
+answers `DEPLOY_FEE_REQUIRED` (402) with the price, instead of
+`NO_DEPLOY_CREDIT`. An unspent AgentFactory credit still deploys without
+paying. Code that matched `NO_DEPLOY_CREDIT` should match
+`DEPLOY_FEE_REQUIRED`.
+
+### Fixes
+
+**`DeployAgentParams` matches the backend.**
+- `provider` includes `'0g-compute'`.
+- `apiKey` is optional (not needed for `0g-compute`).
+- `skillSlugs`, `toolSecrets` and `feeTxHash` are accepted.
+- `ownerAddress` is optional and ignored. The backend never read it; the owner
+  is the API key's wallet.
+- The `deploy_agent` tool follows, and never pays: it takes `feeTxHash`.
+
+**`CreateTaskTx` gains `chain` and `chainId`.** `cancelTask()` and
+`claimTimeout()` are typed with them too. The backend always returned them.
+
+**`uploadBlob()` takes base64**, as the backend reads it. The parameter was
+typed `Hex`, and a hex string uploaded the wrong bytes.
+
+## 0.6.4
+
+### Fixes
+
+**`WorkerRuntime` can take tasks on Arc.** Production posts new tasks on Arc
+(Arc Testnet, chain 5042002) since backend #73, but `SETTLEMENT_CHAINS` was
+`['0g', 'base']`, so a runtime never declared Arc and threw on any task whose
+`chain` was `'arc'`. `SETTLEMENT_CHAINS` is now `['0g', 'base', 'arc']` and
+`A2APublicTaskMeta.chain` includes `'arc'`. To claim Arc tasks set
+`rpcUrls.arc`; a runtime without it keeps declaring only the chains it has an
+RPC for, and says so at start. The README examples and the "no RPC
+configured" error now name `rpcUrls.arc` first.
+
+## 0.6.3
+
+### Fixes
+
+**A scheduled NEEDS_WRAP re-try is no longer refused by its own back-off.**
+`WorkerRuntime` re-tries a task that is waiting for its key to be wrapped on a
+timer. A timer can fire up to a millisecond before `Date.now()` reaches the
+back-off it was set for, and the re-try then counted as too early: nothing
+re-tried the task until the next browse (by default up to 15 s later). Nothing was lost,
+it was only late. No API change.
+
+### Documentation
+
+The `supportedChains` doc comments (`RegisterExecutorInput`,
+`ExecutorProfile`, `WorkerRuntime`, the `register_as_executor` tool, README) now
+say what newer backends do with the list: they leave the executor out of
+offers and refuse bids and `/accept` (409 `CHAIN_UNSUPPORTED`) for tasks on
+chains it did not declare. Older backends only store it. No backend filters
+browse results by it, so `WorkerRuntime` still checks a task's chain itself.
+
 ## 0.6.0
 
 ### Breaking changes

package/README.md

@@ -139,38 +139,73 @@ const response = await anthropic.messages.create({
 
 ## Usage
 
-### Task lifecycle
+### Posting a task
 
-```ts
-// List open tasks
-const tasks = await bb.listTasks();
+`postTask()` does the whole post from the API key owner's wallet, on the
+backend's posting chain (Arc on production, where gas is paid in USDC):
+it encrypts the brief and wraps its key to the executors that can take it,
+uploads it, approves the escrow for the amount, funds it and lists the task.
+Before anything is sent it checks the signer is the API key's own wallet, that
+its RPC is on the posting chain, and that the wallet holds the amount.
 
-// Get task details (includes A2A state + verification result)
-const task = await bb.getTask(taskId);
-
-// Build unsigned createTask tx (sign & broadcast with your wallet — the API
-// key's owner is the poster). Fields mirror the backend's createTaskSchema.
-const { unsignedTx } = await bb.createTask({
-  taskHash,                 // bytes32: sha256 of the encrypted brief
-  token: usdcAddress,       // payment token on the settlement chain
-  amount: '1000000',        // smallest unit — 1 USDC
-  locationZone: 'global',
-  duration: '86400',        // seconds, as a string; deadline = now + duration
-  targetExecutorType: 'agent',
-  verificationMode: 'auto', // 'manual' | 'auto' | 'agent' — 'oracle' is rejected
-  // 'auto' needs at least one real check or indexing fails (400
-  // AUTO_CRITERIA_REQUIRED). Send the same criteria to /a2a/tasks/index.
-  verificationCriteria: { min_length: 40 },
-  requiredCapabilities: ['data_processing'],
+```ts
+const bb = new BlindMarket({
+  apiKey: process.env.BLINDMARKET_API_KEY!,           // an sk_ key minted while signed in as OWNER
+  executor: { privateKey: process.env.OWNER_PRIVATE_KEY!, rpcUrls: { arc: 'https://rpc.testnet.arc.io' } },
 });
+
+const task = await bb.postTask(
+  {
+    instructions: 'Summarise this paper in five bullets: …',
+    amountRaw: '2000000',              // 2 USDC — the token's smallest unit, 6 decimals
+    // privacy: 'public',              // plaintext brief and result, any agent can work it
+    // verificationMode: 'manual',     // default 'auto' with { min_length: 10, pass_threshold: 60 }
+  },
+  { onFunded: ({ txHash }) => save(txHash) }, // persist it: see below
+);
+// { taskHash, taskId, txHash, chain: 'arc', chainId, rootHash, privacy, wrappedTo, aesKey }
+
+// A task no one has taken, or whose deadline passed, gets its escrow back:
+await bb.cancelAndRefund(task.taskId!);
+await bb.reclaimAfterTimeout(task.taskId!);
 ```
 
-`createTask()` previously sent `agent` / `category` / `deadline`, which the
-backend rejects (400) — those fields are gone from its type.
+If the process dies after the escrow is funded but before the task is listed,
+nothing is lost: `onFunded` got the funding hash, and any error after funding
+carries it (`err.txHash`) with the listing body in `err.body.indexParams`.
+Call `bb.indexTask(err.body.indexParams)` to list it (a repeat is safe), or
+`cancelAndRefund()` it. Don't post the task again.
+
+The lower-level builders are unchanged: `createTask()`, `cancelTask()` and
+`claimTimeout()` return unsigned transactions, now with the `chain` and
+`chainId` to send them on.
+
+```ts
+const tasks = await bb.listTasks();
+const detail = await bb.getTask(taskId);
+const { postingChain, chains } = await bb.getSettlement(); // where tasks are posted, and in what token
+```
 
 ### Agent management
 
+Deploying a hosted agent costs a fee: 1 USDC on Arc on production (`bb.getDeployFee()` says what this backend charges). An unspent AgentFactory credit pays first. Otherwise `deployAgent()` pays only when asked (`payFee: true`), from the API key owner's wallet: the configured `executor` (with `rpcUrls.arc`) or a `payer` signer.
+
+Before paying it checks four things: the request (so a deploy that would be refused costs nothing), the payer's wallet, the payer's chain, and the fee against `maxFeeRaw` (default 1 USDC). The payment's hash goes to `onFeePaid` the moment it is sent. If the deploy then fails, the error carries it as `err.feeTxHash`: pass it back as `params.feeTxHash` and nothing is paid twice. A retry whose payment already created your agent returns that agent with `alreadyDeployed: true`.
+
 ```ts
+const owner = new ethers.Wallet(process.env.OWNER_PRIVATE_KEY!);
+const deployed = await bb.deployAgent({
+  name: 'research-agent',
+  instructions: 'You research topics and report back with sources.',
+  provider: 'openai',
+  model: 'gpt-4o-mini',
+  apiKey: process.env.OPENAI_API_KEY!,
+  ownerPublicKey: owner.signingKey.publicKey.slice(2), // uncompressed, no 0x
+}, { payFee: true, onFeePaid: (hash) => save(hash) });
+
+// Check a request without paying or saving anything:
+await bb.validateDeploy({ /* same params */ });
+
 // List agents
 const agents = await bb.listAgents(wallet.address);
 
@@ -197,7 +232,7 @@ const bb = new BlindMarket({
   apiKey,
   // Optional: the API key owner's wallet + an RPC per chain your tasks settle
   // on. Enables deliverResult() and the submit_result tool.
-  executor: { privateKey, rpcUrls: { base: 'https://sepolia.base.org' } },
+  executor: { privateKey, rpcUrls: { arc: 'https://rpc.testnet.arc.io', base: 'https://sepolia.base.org' } },
 });
 
 // Register as an executor. The executor ADDRESS is always the API key's owner
@@ -208,10 +243,11 @@ await bb.registerExecutor({
   capabilities: ['data_processing', 'web_research'],
   // Uncompressed, no 0x. `wallet.publicKey` is the compressed key, which is rejected.
   publicKey: wallet.signingKey.publicKey.slice(2),
-  // Chains you can sign submitEvidence on (optional). A declaration only: the
-  // backend stores it but does NOT filter offers or /accept by it — check
-  // entry.meta.chain yourself before accepting (WorkerRuntime does).
-  supportedChains: ['0g', 'base'],
+  // Chains you can sign submitEvidence on (optional). Older backends only
+  // store it; newer ones also leave you out of offers and refuse /accept
+  // (409 CHAIN_UNSUPPORTED) on other chains. Neither filters browse results,
+  // so check entry.meta.chain before accepting (WorkerRuntime does).
+  supportedChains: ['arc', 'base'],
 });
 
 // Browse available tasks — entries are { meta, state }
@@ -265,16 +301,16 @@ const runtime = new WorkerRuntime({
   // the owner's.
   privateKey: process.env.EXECUTOR_PRIVATE_KEY!,
   // REQUIRED: at least one RPC, on the network your `apiBase` settles on.
-  // There is NO default. `rpcUrl` is the 0G RPC only; it never stands in for Base.
-  rpcUrl: process.env.OG_RPC_URL!, // e.g. https://evmrpc.0g.ai (0G mainnet) or https://evmrpc-testnet.0g.ai
-  // Without this entry the runtime skips Base tasks. Use the Base network your
-  // backend's escrow is deployed on (e.g. https://sepolia.base.org for Base Sepolia).
-  rpcUrls: { base: process.env.BASE_RPC_URL! },
+  // There is NO default. Production posts new tasks on Arc (Arc Testnet,
+  // https://rpc.testnet.arc.io); without `rpcUrls.arc` the runtime skips them.
+  // `base` covers older Base Sepolia tasks. `rpcUrl` is the 0G RPC only and
+  // never stands in for another chain.
+  rpcUrls: { arc: process.env.ARC_RPC_URL!, base: process.env.BASE_RPC_URL! },
   executeTask: async ({ instructions }) => ({ output: await doTheWork(instructions) }),
 });
 
 await runtime.start(); // warns if a chain the SDK supports has no RPC configured
-console.log(runtime.declaredChains); // ['0g', 'base']
+console.log(runtime.declaredChains); // ['base', 'arc']
 ```
 
 **Key and RPC are mandatory.** Up to 0.5.x a runtime with no key registered a
@@ -295,9 +331,10 @@ cross-check; `existingPublicKey` is ignored (derived from the key).
 
 **What keeps the runtime off a chain it cannot settle.** A task is escrowed on
 exactly one chain and `submitEvidence` must be signed there. The runtime
-registers the chains it has an RPC for as `supportedChains`, but that is a
-declaration only: the backend stores it and does **not** filter offers, browse
-results or `/accept` by it. The enforcement is client-side, in the runtime:
+registers the chains it has an RPC for as `supportedChains`. Older backends
+only store it; newer ones also keep other chains' tasks out of its offers and
+refuse its `/accept` on them (409 `CHAIN_UNSUPPORTED`), but no backend filters
+browse results by it. So the runtime enforces it itself, on every backend:
 browse skips entries whose `meta.chain` it did not declare, and after `/accept`
 it fails the task before running your handler if the response names a chain it
 has no RPC for (that task is already assigned — this only covers rows with no
@@ -390,7 +427,7 @@ const leaderboard = await bb.getLeaderboard(10);
 ### Storage
 
 ```ts
-const { rootHash } = await bb.uploadBlob('0x...');
+const { rootHash } = await bb.uploadBlob(Buffer.from(bytes).toString('base64')); // base64, not hex
 const { blob } = await bb.downloadBlob(rootHash); // base64
 ```
 

package/dist/apiError.d.ts

@@ -0,0 +1,26 @@
+/**
+ * An error from the BlindMarket backend, or from a spend the client ran for
+ * you. It is a module of its own so the on-chain helpers can throw it without
+ * importing the client.
+ */
+export declare class ApiError extends Error {
+    status: number;
+    body?: unknown | undefined;
+    /** Backend error code (e.g. 'NEEDS_WRAP', 'NOT_SUBMITTED_ON_CHAIN'), when the envelope carried one. */
+    code?: string | undefined;
+    /** Backend sub-reason within `code` (e.g. 'PAYER_NOT_LINKED'), when the envelope carried one. */
+    reason?: string;
+    /**
+     * A deploy fee transaction that was already paid when this error happened.
+     * Pass it back as `params.feeTxHash` and the retry pays nothing.
+     */
+    feeTxHash?: string;
+    /**
+     * A transaction that was already sent when this error happened (postTask's
+     * escrow funding, a refund). Check it before sending another.
+     */
+    txHash?: string;
+    constructor(status: number, message: string, body?: unknown | undefined, 
+    /** Backend error code (e.g. 'NEEDS_WRAP', 'NOT_SUBMITTED_ON_CHAIN'), when the envelope carried one. */
+    code?: string | undefined);
+}

package/dist/apiError.js

@@ -0,0 +1,31 @@
+/**
+ * An error from the BlindMarket backend, or from a spend the client ran for
+ * you. It is a module of its own so the on-chain helpers can throw it without
+ * importing the client.
+ */
+export class ApiError extends Error {
+    status;
+    body;
+    code;
+    /** Backend sub-reason within `code` (e.g. 'PAYER_NOT_LINKED'), when the envelope carried one. */
+    reason;
+    /**
+     * A deploy fee transaction that was already paid when this error happened.
+     * Pass it back as `params.feeTxHash` and the retry pays nothing.
+     */
+    feeTxHash;
+    /**
+     * A transaction that was already sent when this error happened (postTask's
+     * escrow funding, a refund). Check it before sending another.
+     */
+    txHash;
+    constructor(status, message, body, 
+    /** Backend error code (e.g. 'NEEDS_WRAP', 'NOT_SUBMITTED_ON_CHAIN'), when the envelope carried one. */
+    code) {
+        super(message);
+        this.status = status;
+        this.body = body;
+        this.code = code;
+        this.name = 'ApiError';
+    }
+}

package/dist/executor/WorkerRuntime.d.ts

@@ -52,7 +52,7 @@ export interface WorkerRuntimeConfig {
      * DEFAULT (0.5.x defaulted to 0G testnet while `apiBase` defaults to
      * production, so a default runtime accepted mainnet tasks and failed the
      * chainId pin after assignment). It is 0G ONLY: it never stands in for
-     * another chain. For Base set `rpcUrls.base`. Must be the same network the
+     * another chain. For Base set `rpcUrls.base`, for Arc `rpcUrls.arc`. Must be the same network the
      * backend at `apiBase` settles on.
      */
     rpcUrl?: string;
@@ -72,7 +72,7 @@ export interface WorkerRuntimeConfig {
  * Chains this runtime's CODE can sign submitEvidence on. What it registers as
  * its `supportedChains` is the subset it also has an RPC for (declaredChains).
  */
-export declare const SETTLEMENT_CHAINS: readonly ["0g", "base"];
+export declare const SETTLEMENT_CHAINS: readonly ["0g", "base", "arc"];
 export type SettlementChain = (typeof SETTLEMENT_CHAINS)[number];
 export type ExecuteTaskHandler = (ctx: TaskContext) => Promise<Record<string, unknown>>;
 export interface TaskContext {
@@ -160,8 +160,9 @@ export declare class WorkerRuntime {
     get activeExecutions(): TaskExecutionInfo[];
     /**
      * The chains this runtime declares to the backend and claims tasks on:
-     * those its code can sign for AND it has an RPC for. The backend stores the
-     * list but does not filter by it — browse() and executeTask() enforce it.
+     * those its code can sign for AND it has an RPC for. Older backends only
+     * store the list and none filters browse results by it, so browse() and
+     * executeTask() enforce it.
      */
     get declaredChains(): SettlementChain[];
     /** Get own executor profile (available after start). */
@@ -180,8 +181,8 @@ export declare class WorkerRuntime {
      * chain this runtime has no RPC for — it would be offered, accept and
      * strand those tasks. A stored list that is a SUBSET of what the runtime
      * can settle is left alone: an operator who registered ['base'] through
-     * the MCP or PATCH meant it. The stored list is a declaration only — the
-     * backend does not filter offers by it; this runtime's own browse filter
+     * the MCP or PATCH meant it. Older backends only store the list (newer ones
+     * also filter offers and /accept by it); this runtime's own browse filter
      * uses `declaredChains`, not the stored list — and a restore never
      * registers otherwise, so an executor first registered by an older SDK
      * would keep its old list.
@@ -210,7 +211,10 @@ export declare class WorkerRuntime {
     private browse;
     /** Executions holding a concurrency slot. A task waiting for a wrap or backing off holds none. */
     private inFlight;
-    /** Start executing `taskId` if it is not running, not backing off, and a slot is free. */
+    /**
+     * Start executing `taskId` if it is not running, not backing off, and a slot
+     * is free. `dueAt`: the time a scheduled re-try counts as running at.
+     */
     private claim;
     private retryState;
     /**

package/dist/executor/WorkerRuntime.js

@@ -5,7 +5,7 @@ import { eciesDecrypt, aesDecrypt, derivePublicKey } from '../crypto/index.js';
  * Chains this runtime's CODE can sign submitEvidence on. What it registers as
  * its `supportedChains` is the subset it also has an RPC for (declaredChains).
  */
-export const SETTLEMENT_CHAINS = ['0g', 'base'];
+export const SETTLEMENT_CHAINS = ['0g', 'base', 'arc'];
 /**
  * The chain the backend named for a task. Missing means 0G (backends older
  * than the field). Any other value throws: signing it on the 0G RPC would
@@ -16,7 +16,7 @@ function settlementChain(taskId, reported) {
         return '0g';
     const known = SETTLEMENT_CHAINS.find((c) => c === reported);
     if (!known) {
-        throw new Error(`task ${taskId} settles on "${reported}", which this runtime cannot sign for (it signs on ${SETTLEMENT_CHAINS.join(' and ')}) — update @blindmarket/sdk`);
+        throw new Error(`task ${taskId} settles on "${reported}", which this runtime cannot sign for (it signs on ${SETTLEMENT_CHAINS.join(', ')}) — update @blindmarket/sdk`);
     }
     return known;
 }
@@ -95,8 +95,9 @@ export class WorkerRuntime {
     }
     /**
      * The chains this runtime declares to the backend and claims tasks on:
-     * those its code can sign for AND it has an RPC for. The backend stores the
-     * list but does not filter by it — browse() and executeTask() enforce it.
+     * those its code can sign for AND it has an RPC for. Older backends only
+     * store the list and none filters browse results by it, so browse() and
+     * executeTask() enforce it.
      */
     get declaredChains() {
         return SETTLEMENT_CHAINS.filter((chain) => !!rpcFor(this.config, chain));
@@ -132,7 +133,7 @@ export class WorkerRuntime {
                 'BlindMarket.browseA2ATasks() directly.');
         }
         if (this.declaredChains.length === 0) {
-            throw new Error('[WorkerRuntime] no RPC configured. Set `rpcUrl` (0G) and/or `rpcUrls.base` to the network the backend at ' +
+            throw new Error('[WorkerRuntime] no RPC configured. Set `rpcUrls.arc` (where production posts new tasks), `rpcUrls.base` and/or `rpcUrl` (0G) to the network the backend at ' +
                 '`apiBase` settles on. There is no default: submitEvidence is signed on this RPC after the task is already ' +
                 'assigned, so a guessed network strands it.');
         }
@@ -143,7 +144,7 @@ export class WorkerRuntime {
             console.warn(`[WorkerRuntime] declaring chains: ${this.declaredChains.join(', ') || 'none'}. ` +
                 `No RPC for ${undeclared.join(', ')} — tasks on ${undeclared.length > 1 ? 'those chains' : 'that chain'} are skipped; ` +
                 `set ${undeclared.map((c) => `rpcUrls.${c}`).join(', ')} to claim them ` +
-                `(production posts new tasks on Base).`);
+                `(production posts new tasks on Arc).`);
         }
         // 1. Register or restore executor
         if (this.config.privateKey) {
@@ -191,8 +192,8 @@ export class WorkerRuntime {
      * chain this runtime has no RPC for — it would be offered, accept and
      * strand those tasks. A stored list that is a SUBSET of what the runtime
      * can settle is left alone: an operator who registered ['base'] through
-     * the MCP or PATCH meant it. The stored list is a declaration only — the
-     * backend does not filter offers by it; this runtime's own browse filter
+     * the MCP or PATCH meant it. Older backends only store the list (newer ones
+     * also filter offers and /accept by it); this runtime's own browse filter
      * uses `declaredChains`, not the stored list — and a restore never
      * registers otherwise, so an executor first registered by an older SDK
      * would keep its old list.
@@ -310,9 +311,10 @@ export class WorkerRuntime {
                     continue;
                 // An accept assigns on-chain and cannot be released, so never claim a
                 // task browse already says is on a chain this runtime did not declare.
-                // The backend does not filter by the registered supportedChains, so
-                // this filter (and the post-accept check in executeTask, which covers
-                // rows with no chain) is the only thing keeping such tasks out.
+                // No backend filters browse results by the registered
+                // supportedChains (older ones filter nothing by it), so this filter
+                // (and the post-accept check in executeTask, which covers rows with
+                // no chain) is what keeps such tasks out.
                 if (entry.meta?.chain && !this.declaredChains.includes(entry.meta.chain))
                     continue;
                 this.claim(taskId, state, entry.meta);
@@ -341,12 +343,15 @@ export class WorkerRuntime {
         }
         return n;
     }
-    /** Start executing `taskId` if it is not running, not backing off, and a slot is free. */
-    claim(taskId, state, meta) {
+    /**
+     * Start executing `taskId` if it is not running, not backing off, and a slot
+     * is free. `dueAt`: the time a scheduled re-try counts as running at.
+     */
+    claim(taskId, state, meta, dueAt = Date.now()) {
         if (this.executions.has(taskId))
             return false;
         const retry = this.retries.get(taskId);
-        if (retry && retry.notBefore > Date.now())
+        if (retry && retry.notBefore > dueAt)
             return false;
         if (this.inFlight() >= this.config.maxConcurrentTasks)
             return false;
@@ -492,11 +497,16 @@ export class WorkerRuntime {
     scheduleRetry(taskId, a2a, meta, ms) {
         if (!this.running)
             return;
+        // The back-off this timer ends. A timer can fire before Date.now() reaches
+        // it (they run on different clocks), and the re-try must not then be
+        // refused by its own back-off: nothing would re-try it before the next
+        // browse. A back-off set after this one still holds.
+        const due = this.retries.get(taskId)?.notBefore ?? 0;
         const timer = setTimeout(() => {
             this.retryTimers.delete(timer);
             // No free slot / paused: the next browse picks it up instead.
             if (this.running && !this.paused)
-                this.claim(taskId, a2a, meta);
+                this.claim(taskId, a2a, meta, Math.max(due, Date.now()));
         }, ms);
         this.retryTimers.add(timer);
     }