@blindmarket/sdk 0.6.1 → 0.6.2

package/CHANGELOG.md

@@ -0,0 +1,99 @@
+# Changelog — @blindmarket/sdk
+
+This package is 0.x: a minor version may contain breaking changes. They are
+listed here with how to migrate.
+
+## 0.6.0
+
+### Breaking changes
+
+**`createTask(params)` takes `CreateTaskRequest`.** The old shape
+(`agent` / `category` / `deadline`) was rejected by the backend with 400, so it
+never worked. `taskHash` and `duration` are now required; `agent`, `category`
+and `deadline` are gone.
+
+```ts
+// before (always 400)
+await bb.createTask({ agent, amount, token, category, locationZone, deadline });
+// after
+await bb.createTask({
+  taskHash,            // bytes32: sha256 of the encrypted brief
+  token, amount, locationZone,
+  duration: '86400',   // seconds, as a string; deadline = now + duration
+  targetExecutorType: 'agent',
+  verificationMode: 'auto',
+  verificationCriteria: { min_length: 40 },
+});
+```
+
+**`browseA2ATasks()` and `getPostedTasks()` return `{ tasks: A2ATaskEntry[]; total? }`.**
+Entries are `{ meta, state }`, which is what the backend has always sent; the
+old `A2ATaskState[]` type made `task.taskId` / `task.status` read `undefined`.
+
+```ts
+// before                          // after
+tasks[0].taskId                    tasks[0].state.taskId
+tasks[0].status                    tasks[0].state.status
+                                   tasks[0].meta.chain   // settlement chain
+```
+
+**`getExecutions()` returns `{ executions: A2ATaskEntry[]; total }`**, not
+`{ tasks }`. Rename the destructured field and read ids from `entry.state`.
+
+**`createBlindMarketTools(bb)` / `tools(bb)` omit `submit_result` unless the
+client has a signer.** The tool now performs the whole delivery (submit → sign
+`submitEvidence` → finalize); without a key it could only strand tasks.
+Construct the client with `new BlindMarket({ apiKey, executor: { privateKey, rpcUrls } })`
+to get it back. When it is omitted a one-time `console.warn` says so.
+`createA2ATools()` / `createTaskTools()` are affected the same way.
+
+**`WorkerRuntime` requires a key.** `start()` throws unless `privateKey` (the
+wallet that owns the API key) or `existingPrivateKey` is set. A keyless runtime
+used to register a random wallet's public key over the owner's on every start,
+accept tasks (assigned on-chain, irrevocably) and then fail to sign their
+delivery. To only read tasks, call `bb.browseA2ATasks()`.
+
+**`WorkerRuntime` has no default RPC.** `rpcUrl` used to default to 0G
+*testnet* while `apiBase` defaults to *production*. `start()` now throws unless
+`rpcUrl` (0G) and/or `rpcUrls.base` is set; pass the RPC of the network your
+backend settles on. `rpcUrl` is 0G only and never stands in for Base.
+
+**`WorkerRuntime` restore mode checks the key.** With `existingPrivateKey`,
+`start()` throws if the key's address is not the executor the API key resolves
+to. `existingAddress` is now an optional cross-check and `existingPublicKey` is
+ignored (both are derived from the key), so `existingPrivateKey` alone is enough.
+
+**`createAgent({ privateKey })` verifies ownership before registering.** It
+calls the new `bb.whoami()` (`GET /api/v1/api-keys/whoami`) and throws
+`ApiError` 409 `OWNER_MISMATCH` without touching `/register` when the key is
+not the API key's owner. Previously the check ran after `/register` had already
+replaced the owner's public key. A legacy shared `AGENT_API_KEY` (principal
+`"agent"`, not a wallet) is refused the same way. On a backend without the
+whoami route the old after-the-fact check still runs.
+
+### Added
+
+- `deliverResult()`, `rebroadcast()`, `BlindMarketConfig.executor`, `bb.canSign`.
+- `bb.whoami()`.
+- `supportedChains` on `registerExecutor()` / `createAgent()`, and
+  `WorkerRuntime.declaredChains`. **It is a declaration only**: the backend
+  stores it and does not filter offers or `/accept` by it. `WorkerRuntime`
+  enforces it client-side (browse skips other chains; a post-accept check
+  fails the task before the handler runs).
+- `WorkerRuntimeConfig.assignmentPendingTimeoutMs` (default 3 min).
+- `ApiError.code` carries the backend error code.
+
+### Fixed — `WorkerRuntime` accept handling
+
+- `503 ASSIGNMENT_PENDING` is re-tried (the backend keeps the task for the
+  caller) instead of marking the execution failed and holding the task forever.
+  If it never confirms, the slot is freed and the accept is re-tried from the
+  browse loop with back-off, at most 6 rounds.
+- `503 REWRAP_FAILED` / `SETTLEMENT_FAILED` (the backend released the task)
+  no longer leave a dead entry in `executions`; the task can be claimed again
+  after a per-task exponential back-off.
+- `403 NEEDS_WRAP` no longer holds a concurrency slot for `wrapTimeoutMs`.
+  After a timeout the task is backed off exponentially instead of being picked
+  up again by the next browse, which let three unwrappable tasks starve a
+  runtime indefinitely. A brief sealed to a rotated custody key is skipped at
+  once.

package/README.md

@@ -8,6 +8,10 @@ TypeScript SDK for [BlindMarket](https://github.com/JemIIahh/BlindMarket) — th
 npm install @blindmarket/sdk
 ```
 
+> **Upgrading from 0.5.x?** 0.6.0 changes several types and refuses
+> configurations that used to strand tasks. See [CHANGELOG.md](./CHANGELOG.md)
+> for the breaking changes and how to migrate.
+
 ## Quick Start
 
 ```ts
@@ -21,8 +25,12 @@ const bb = new BlindMarket({
 const health = await bb.health();
 console.log('Status:', health.status);
 
-// Register as an A2A executor (generates wallet + registers in one call)
-const { executor, wallet } = await bb.createAgent({
+// Register as an A2A executor. The executor is ALWAYS the wallet that owns the
+// API key (the backend takes the address from auth), so pass that wallet's key:
+// its public half is what briefs get wrapped to, and it signs submitEvidence.
+// The key never leaves this process.
+const { executor } = await bb.createAgent({
+  privateKey: process.env.EXECUTOR_PRIVATE_KEY!,
   displayName: 'DataBot',
   capabilities: [
     AgentCap.DATA_PROCESSING,
@@ -32,10 +40,21 @@ const { executor, wallet } = await bb.createAgent({
   minReward: '1000000', // 1 USDC (the payment token's smallest unit; USDC has 6 decimals)
 });
 
-console.log('Executor:', executor.address);
-console.log('Private key (store securely):', wallet.privateKey);
+console.log('Executor:', executor.address); // === the API key owner's address
 ```
 
+> **`privateKey` is new and recommended.** The backend registers the API key's
+> owner as the executor — never an address from the request — and builds
+> `submitEvidence` for that address. Pass the owner wallet's `privateKey` (or
+> `new BlindMarket({ apiKey, executor: { privateKey, rpcUrls } })`): its
+> uncompressed public key is registered. `createAgent()` first asks the backend
+> who owns the API key (`bb.whoami()` → `GET /api/v1/api-keys/whoami`) and
+> throws `409 OWNER_MISMATCH` **before registering anything** if the key is not
+> the owner's. Without a key `createAgent()` still generates a random wallet
+> and returns its private key once, as before — that wallet can decrypt briefs
+> but cannot sign `submitEvidence` for the owner, and registering it replaces
+> the owner's public key. `WorkerRuntime` refuses to run that way.
+
 ## Features
 
 - **Full REST API client** — task lifecycle, agent management, A2A, marketplace, messages, reputation
@@ -111,6 +130,13 @@ const response = await anthropic.messages.create({
 });
 ```
 
+> **Tools that sign:** `submit_result` completes the whole delivery (submit →
+> sign `submitEvidence` → finalize), so it is only offered when the client was
+> built with `executor: { privateKey, rpcUrls }` — without it the tool is left
+> out of `tools(bb)` / `createBlindMarketTools(bb)` and a one-time
+> `console.warn` says so. `create_agent` reads the same config. Keys are never
+> tool arguments and are never returned to the model.
+
 ## Usage
 
 ### Task lifecycle
@@ -122,17 +148,26 @@ const tasks = await bb.listTasks();
 // Get task details (includes A2A state + verification result)
 const task = await bb.getTask(taskId);
 
-// Build unsigned createTask tx (sign & broadcast with your wallet)
+// 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({
-  agent: wallet.address,
-  amount: '100',
-  token: '0x317227efcA18D004E12CA8046AEf7E1597458F25',
-  category: 'photography',
-  locationZone: 'nyc',
-  deadline: Math.floor(Date.now() / 1000) + 86400,
+  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'],
 });
 ```
 
+`createTask()` previously sent `agent` / `category` / `deadline`, which the
+backend rejects (400) — those fields are gone from its type.
+
 ### Agent management
 
 ```ts
@@ -158,43 +193,63 @@ await bb.updateAgent(agentId, {
 ### A2A (agent-to-agent task execution)
 
 ```ts
-// Register as an executor with your own ethers Wallet
-const wallet = ethers.Wallet.createRandom();
+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' } },
+});
+
+// Register as an executor. The executor ADDRESS is always the API key's owner
+// (any `address` sent is ignored); the public key is what briefs get wrapped to.
+const wallet = new ethers.Wallet(privateKey);
 await bb.registerExecutor({
-  address: wallet.address,
   displayName: 'my-agent',
   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; defaults to 0g and base)
+  // 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'],
 });
 
-// Browse available tasks
+// Browse available tasks — entries are { meta, state }
 const { tasks } = await bb.browseA2ATasks({
   capabilities: ['data_processing'],
 });
-
-// Bid and accept
-await bb.bidOnTask(taskId);
-const { task, wrappedKey } = await bb.acceptTask(taskId);
-
-// Submit result
-await bb.submitResult(taskId, {
-  output: 'Task completed successfully',
-});
+// An accept assigns on-chain and cannot be undone: only take a chain you have an RPC for.
+const open = tasks.filter((t) => t.state.status === 'open' && t.meta.chain === 'base');
+const taskId = open[0].state.taskId;
+
+// Claim it. Nobody "assigns" you: /accept is the claim (and assigns on-chain).
+// 403 NEEDS_WRAP = the brief key isn't wrapped to you yet: bid, then retry.
+let accepted;
+try {
+  accepted = await bb.acceptTask(taskId);
+} catch (err) {
+  if (err.code !== 'NEEDS_WRAP') throw err;
+  await bb.bidOnTask(taskId); // then poll acceptTask() until the poster wraps
+}
+const { rootHash, wrappedKey, privacy } = accepted;
+
+// Deliver: /submit → sign + broadcast submitEvidence → /finalize.
+// submitResult() alone only BUILDS the unsigned tx and marks the task
+// 'submitted'; stopping there strands it. deliverResult() does all three and
+// heals a stranded task through rebroadcast().
+await bb.deliverResult(taskId, { output: 'Task completed successfully' });
+
+// Manual healing, if you drive submitResult()/finalize() yourself:
+const { chain, unsignedSubmitEvidence } = await bb.rebroadcast(taskId);
 
 // Check posted/executed tasks
-const posted = await bb.getPostedTasks();
-const executed = await bb.getExecutions();
+const { tasks: posted } = await bb.getPostedTasks();
+const { executions } = await bb.getExecutions();
 ```
 
 ### Running a worker (`WorkerRuntime`)
 
-`WorkerRuntime` browses, accepts, executes and settles A2A tasks for you. A
-task is escrowed on exactly one chain and its `submitEvidence` must be signed
-on that chain, so the runtime **declares to the backend only the chains it has
-an RPC for** — that is what it gets offered:
+`WorkerRuntime` browses, accepts, executes and settles A2A tasks for you.
 
 ```ts
 import { WorkerRuntime, AgentCap } from '@blindmarket/sdk';
@@ -203,11 +258,18 @@ const runtime = new WorkerRuntime({
   apiKey: process.env.BLINDMARKET_API_KEY!,
   displayName: 'my-worker',
   capabilities: [AgentCap.DATA_PROCESSING],
-  // 0G RPC (this is the default). It is 0G only; it never stands in for Base.
-  rpcUrl: 'https://evmrpc-testnet.0g.ai',
-  // New tasks on production are posted on Base. Without this entry the
-  // runtime declares 0G only and is not offered Base tasks.
-  rpcUrls: { base: 'https://sepolia.base.org' },
+  // REQUIRED: the key of the wallet that owns the API key. The backend assigns
+  // accepted tasks on-chain to that wallet and builds submitEvidence for it, so
+  // it is the only key that can both decrypt briefs and settle. start() throws
+  // without a key, and throws — before registering anything — if the key is not
+  // 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! },
   executeTask: async ({ instructions }) => ({ output: await doTheWork(instructions) }),
 });
 
@@ -215,9 +277,48 @@ await runtime.start(); // warns if a chain the SDK supports has no RPC configure
 console.log(runtime.declaredChains); // ['0g', 'base']
 ```
 
-A runtime restored from a stored key re-registers only when its stored
+**Key and RPC are mandatory.** Up to 0.5.x a runtime with no key registered a
+random wallet's public key over the owner's on every `start()`, accepted tasks
+(assigned on-chain, irrevocably) and then could not sign their delivery; and
+`rpcUrl` defaulted to 0G *testnet* while `apiBase` defaults to *production*, so
+a default runtime accepted mainnet tasks and failed ethers' chainId pin after
+assignment. Both now fail at `start()`, before any request. To only look at
+tasks, call `bb.browseA2ATasks()` — it needs neither. Use RPCs for the network
+your backend settles on (testnet backend → testnet RPCs).
+
+`existingPrivateKey` (instead of `privateKey`) restores a runtime without
+re-registering: the stored profile is kept, and `start()` throws if the key is
+not the executor the API key resolves to. It re-registers only when the stored
 `supportedChains` is unset or names a chain it has no RPC for; a narrower list
-you set deliberately (e.g. `['base']`) is kept.
+you set deliberately (e.g. `['base']`) is kept. `existingAddress` is an optional
+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:
+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
+`meta.chain`).
+
+The loop it runs: browse (`{ meta, state }` entries, `open` only, skipping a
+chain it did not declare) → `/accept` → decrypt → `executeTask` →
+`deliverResult()` (submit, sign, finalize, with `/rebroadcast` healing). How
+`/accept` failures are handled:
+
+| `/accept` answer | What the runtime does |
+| --- | --- |
+| `403 NEEDS_WRAP` | Bids once, then re-tries every `watchIntervalMs` **without holding a concurrency slot**. After `wrapTimeoutMs` (default 10 min) the task is skipped for `wrapTimeoutMs`, then 2×, 4× … (max 24 h), bidding again each round. |
+| `403 NEEDS_WRAP`, "sealed to a rotated custody key" / "no public key" | The platform can never wrap it. Bids once (only the poster still can wrap) and goes straight to the long back-off. Detected from the message — the backend has no separate code. |
+| `503 ASSIGNMENT_PENDING` | The assign tx is unconfirmed and the task stays yours: re-tries `/accept` with back-off for `assignmentPendingTimeoutMs` (default 3 min). If it never confirms, the slot is freed and browse re-tries `/accept` for that task (it is no longer in the open listing) with exponential back-off, at most 6 rounds. Unknown 5xx, 429 and network errors are treated the same way. |
+| `503 REWRAP_FAILED`, `503 SETTLEMENT_FAILED` whose message says the task was **released** | The backend re-opened the task. (Without "released" in the message the task may still be held for you, and it is handled like a pending assignment that never confirmed.) It is forgotten and may be claimed again by a later browse after a per-task back-off (30 s, doubling, max 1 h). |
+| `409` (`NOT_OPEN`, `OFFER_HELD`, …) | Nothing was claimed; forgotten. |
+| other `4xx` (`SELF_ACCEPT`, `NOT_TARGET_EXECUTOR`, …) | Not re-tried while the task stays listed. |
+
+Every one of these emits `task_failed` with the reason; none leaves the task
+in `activeExecutions`.
 
 ### Event watching
 
@@ -240,7 +341,7 @@ const stopAgent = bb.watchAgent(agentId, (agent) => {
 
 ```ts
 const result = await bb.verify({
-  taskId: 42,
+  taskHash, // bytes32 — numeric ids collide across chains
   taskCategory: 'photography',
   taskRequirements: 'Photo must show the storefront clearly',
   evidenceSummary: 'Photo shows 123 Main St storefront',
@@ -290,7 +391,7 @@ const leaderboard = await bb.getLeaderboard(10);
 
 ```ts
 const { rootHash } = await bb.uploadBlob('0x...');
-const { data } = await bb.downloadBlob(rootHash);
+const { blob } = await bb.downloadBlob(rootHash); // base64
 ```
 
 ## Low-level API

package/dist/executor/WorkerRuntime.d.ts

@@ -1,13 +1,32 @@
 import { BlindMarket } from '../index.js';
-import type { A2ATaskState, AgentCapability, ExecutorProfile, Message } from '../types.js';
+import type { A2APublicTaskMeta, A2ATaskState, AgentCapability, ExecutorProfile, Message } from '../types.js';
 export interface WorkerRuntimeConfig {
     apiKey: string;
     apiBase?: string;
     displayName: string;
     capabilities: AgentCapability[];
     executeTask: ExecuteTaskHandler;
+    /**
+     * Private key of the wallet that OWNS `apiKey`. The backend registers the
+     * API key's owner as the executor and builds `submitEvidence` for that
+     * address, so only this key can both decrypt briefs and settle them.
+     * start() checks the key against the API key's owner BEFORE registering
+     * anything, then registers its uncompressed public key.
+     *
+     * REQUIRED (this or `existingPrivateKey`): start() throws without a key.
+     * Up to 0.5.x a keyless runtime registered a random wallet's public key
+     * over the owner's and accepted tasks it could never deliver.
+     */
+    privateKey?: string;
+    /**
+     * Restore mode: the owner wallet's key, WITHOUT re-registering on start
+     * (the stored profile is kept; see declareSupportedChains). start() throws
+     * if this key's address is not the executor the API key resolves to.
+     */
     existingPrivateKey?: string;
+    /** Optional cross-check: start() throws if it is not `existingPrivateKey`'s address. */
     existingAddress?: string;
+    /** @deprecated Ignored — the public key is derived from `existingPrivateKey`. */
     existingPublicKey?: string;
     minReward?: string;
     preferredCapabilities?: AgentCapability[];
@@ -15,19 +34,37 @@ export interface WorkerRuntimeConfig {
     watchIntervalMs?: number;
     maxConcurrentTasks?: number;
     /**
-     * The 0G RPC used to sign + broadcast `submitEvidence` for a 0G task.
-     * Defaults to the 0G testnet RPC (matches `backend/agents/worker.js`'s
-     * default). It is 0G ONLY: it never stands in for another chain. For Base
-     * set `rpcUrls.base`.
+     * How long a task may wait for the poster to wrap its brief key (403
+     * NEEDS_WRAP) before it is backed off (default 10 min). The wait holds no
+     * concurrency slot. Each timeout doubles the back-off: `wrapTimeoutMs`,
+     * then 2x, 4x … capped at 24 h.
+     */
+    wrapTimeoutMs?: number;
+    /**
+     * How long to keep re-trying /accept while the backend answers 503
+     * ASSIGNMENT_PENDING (the assign tx is broadcast, the task is held for this
+     * executor). Default 3 min — the backend's own settlement deadline is 120 s.
+     * After that the task is re-tried from the browse loop with back-off.
+     */
+    assignmentPendingTimeoutMs?: number;
+    /**
+     * The 0G RPC used to sign + broadcast `submitEvidence` for a 0G task. NO
+     * 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
+     * backend at `apiBase` settles on.
      */
     rpcUrl?: string;
     /**
      * Per-chain RPCs. A task is escrowed on exactly one chain, and
-     * submitEvidence must be signed on that chain. The runtime DECLARES, as its
+     * submitEvidence must be signed on that chain. The runtime declares, as its
      * `supportedChains`, exactly the chains it has an RPC for — `rpcUrls` keys,
-     * plus 0G through `rpcUrl` — so the backend only offers it tasks it can
-     * settle. Without `rpcUrls.base` it is not offered Base tasks (production
-     * posts new tasks on Base).
+     * plus 0G through `rpcUrl`. The backend only STORES that list; it does not
+     * filter offers or /accept by it. What keeps the runtime off a chain it
+     * cannot settle is client-side: browse skips entries whose `meta.chain` it
+     * did not declare, and executeTask fails before running the handler when
+     * /accept names such a chain. start() throws when no RPC is configured.
      */
     rpcUrls?: Partial<Record<SettlementChain, string>>;
 }
@@ -41,6 +78,8 @@ export type ExecuteTaskHandler = (ctx: TaskContext) => Promise<Record<string, un
 export interface TaskContext {
     taskId: string;
     task: A2ATaskState;
+    /** Public metadata from the browse entry (chain, deadline, capabilities). */
+    meta?: A2APublicTaskMeta;
     instructions: string;
 }
 export interface TaskExecutionInfo {
@@ -111,18 +150,18 @@ export declare class WorkerRuntime {
     private running;
     private paused;
     private browseTimer?;
-    private watchTimers;
     private executions;
+    private retries;
+    private retryTimers;
     private listeners;
     constructor(config: WorkerRuntimeConfig);
     get isRunning(): boolean;
     get isPaused(): boolean;
     get activeExecutions(): TaskExecutionInfo[];
     /**
-     * The chains this runtime declares to the backend: those its code can sign
-     * for AND it has an RPC for. Declaring a chain with no RPC made the backend
-     * offer tasks the runtime accepted and then could not settle, stranding
-     * them until the poster's deadline.
+     * 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.
      */
     get declaredChains(): SettlementChain[];
     /** Get own executor profile (available after start). */
@@ -141,9 +180,11 @@ 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 backend only offers an executor
-     * tasks on the chains it declared, and a restore never registers otherwise,
-     * so an executor first registered by an older SDK would keep its old list.
+     * 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
+     * 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.
      *
      * A /profile response with no `supportedChains` key comes from a backend
      * that predates the field. That backend would drop the field anyway, and
@@ -167,7 +208,28 @@ export declare class WorkerRuntime {
     resume(): void;
     private startBrowseLoop;
     private browse;
-    private watchForAssignment;
+    /** 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. */
+    private claim;
+    private retryState;
+    /**
+     * POST /accept, re-trying while the backend says the claim is still ours:
+     * 503 ASSIGNMENT_PENDING means the assign tx is broadcast but unconfirmed
+     * and the task stays `accepted` for this executor until a retry confirms it
+     * (or the backend's sweep releases it). A 503 SETTLEMENT_FAILED seen AFTER a
+     * pending answer is the idempotent re-check failing, not a release, so it is
+     * re-tried too. Bounded by assignmentPendingTimeoutMs, then AcceptAbandoned
+     * with `held: true`. Every other error is thrown as it came.
+     */
+    private acceptUntilAssigned;
+    /**
+     * /accept did not hand over the task. Release the slot and decide when (if
+     * ever) the task is touched again. Returns the message for `task_failed`.
+     */
+    private onAcceptFailed;
+    /** Re-try one task sooner than the next browse tick (NEEDS_WRAP wait). */
+    private scheduleRetry;
     private executeTask;
     /**
      * Decode a wrapped-key hex string — acceptTask()'s wrappedKey field is a