@lucid-agents/taskmarket 1.15.0 → 1.16.0

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { Command as Command86 } from "commander";
+import { Command as Command90 } from "commander";
 import { createRequire } from "module";
 
 // src/commands/init.ts
@@ -275,6 +275,22 @@ var SponsoredTaskVaultReviewRequestOutputSchema = z4.object({
 var SponsoredTaskVaultManagersListInputSchema = z4.object({
   vaultId: VaultIdInputSchema
 });
+var SponsoredTaskManagedVaultsInputSchema = z4.object({
+  managerAddress: VaultAddressSchema,
+  limit: z4.number().int().min(1).max(100).optional().default(50),
+  cursor: z4.string().optional()
+});
+var SponsoredTaskManagedVaultSchema = z4.object({
+  vault: SponsoredTaskVaultSchema,
+  manager: SponsoredTaskVaultManagerSchema.extend({
+    reserved: z4.string(),
+    remainingCap: z4.string()
+  })
+});
+var SponsoredTaskManagedVaultsOutputSchema = z4.object({
+  vaults: z4.array(SponsoredTaskManagedVaultSchema),
+  nextCursor: z4.string().nullable()
+});
 var SponsoredTaskVaultBalanceInputSchema = z4.object({
   vaultId: VaultIdInputSchema
 });
@@ -399,6 +415,7 @@ var SponsoredTaskVaultSettlementHistoryEntrySchema = z4.object({
   feeAmount: z4.string().nullable(),
   netAmount: z4.string().nullable(),
   releasedAmount: z4.string(),
+  awardCount: z4.number().int().nonnegative(),
   transactionHash: z4.string(),
   blockNumber: z4.string(),
   recordedAt: z4.string()
@@ -1635,7 +1652,12 @@ var EcosystemSnapshotInputSchema = z19.object({
   /** Nodes beyond this are dropped by lowest activity; links touching them go with them. */
   maxNodes: z19.number().int().min(1).max(2e4).optional().default(5e3),
   /** Links beyond this are dropped by lowest weight (paid amount, then count). */
-  maxLinks: z19.number().int().min(1).max(1e5).optional().default(2e4)
+  maxLinks: z19.number().int().min(1).max(1e5).optional().default(2e4),
+  /**
+   * The chain to show; omitted means the backend's default chain. Must be one of network.info's
+   * chains.
+   */
+  chainId: z19.number().int().positive().optional()
 });
 var EcosystemNodeSchema = z19.object({
   address: z19.string(),
@@ -1715,6 +1737,11 @@ var EcosystemLifetimeSchema = z19.object({
   weekly: z19.array(EcosystemLifetimeWeekSchema)
 });
 var EcosystemSnapshotResponseSchema = z19.object({
+  /**
+   * The chain this snapshot describes. Optional so a backend deployed before this field, and
+   * responses already cached by clients, still validate; absent means the backend's default chain.
+   */
+  chainId: z19.number().int().optional(),
   generatedAt: z19.string(),
   window: z19.object({ from: z19.string(), to: z19.string() }),
   nodes: z19.array(EcosystemNodeSchema),
@@ -1740,7 +1767,12 @@ var EcosystemSnapshotResponseSchema = z19.object({
 var EcosystemEventsInputSchema = z19.object({
   /** Opaque cursor from a snapshot or a previous events page. Omit for the most recent events. */
   since: z19.string().max(4096).optional(),
-  limit: z19.number().int().min(1).max(200).optional().default(100)
+  limit: z19.number().int().min(1).max(200).optional().default(100),
+  /**
+   * The chain to show; omitted means the backend's default chain. Must be one of network.info's
+   * chains.
+   */
+  chainId: z19.number().int().positive().optional()
 });
 var EcosystemEventSchema = z19.object({
   /** Stable, unique per event; safe to dedupe on. */
@@ -1766,6 +1798,7 @@ var EcosystemEventsResponseSchema = z19.object({
 
 // ../../packages/shared/dist/schemas/evaluation.schemas.js
 import { z as z20 } from "zod";
+var MAX_PAYOUT_RECIPIENTS = 50;
 var EvaluationAwardInputSchema = z20.object({
   worker: z20.string(),
   amount: PositiveUsdcBaseUnitsSchema,
@@ -1777,14 +1810,14 @@ var EvaluateInputSchema = z20.object({
   score: z20.number().int().min(0).max(1e3).optional().default(1e3),
   confidence: z20.number().int().min(0).max(1e3).optional().default(1e3),
   evidenceHash: z20.string().regex(/^0x[0-9a-fA-F]{64}$/).optional().default("0x0000000000000000000000000000000000000000000000000000000000000000"),
-  awards: z20.array(EvaluationAwardInputSchema).optional().default([])
+  awards: z20.array(EvaluationAwardInputSchema).max(MAX_PAYOUT_RECIPIENTS).optional().default([])
 });
 var AppealInputSchema = z20.object({ taskId: z20.string() });
 var FinalizeVerdictInputSchema = z20.object({ taskId: z20.string() });
 var ResolveDisputeInputSchema = z20.object({
   taskId: z20.string(),
   verdict: z20.enum(["approve", "partial"]),
-  awards: z20.array(EvaluationAwardInputSchema).min(1)
+  awards: z20.array(EvaluationAwardInputSchema).min(1).max(MAX_PAYOUT_RECIPIENTS)
 });
 var EvaluatorTimeoutInputSchema = z20.object({ taskId: z20.string() });
 
@@ -3005,8 +3038,8 @@ function formatDreams(baseUnits) {
 function buildSelectWorkerMessage(taskId, pitchId, workerAddress) {
   return `taskmarket:select-worker:${taskId}:${pitchId}:${workerAddress.toLowerCase()}`;
 }
-function buildReadAuthMessage(address2) {
-  return `taskmarket:read:${address2.toLowerCase()}`;
+function buildReadAuthMessage(address3) {
+  return `taskmarket:read:${address3.toLowerCase()}`;
 }
 var READ_AUTH_ADDRESS_HEADER = "X-Taskmarket-Caller-Address";
 var READ_AUTH_SIGNATURE_HEADER = "X-Taskmarket-Caller-Signature";
@@ -3024,8 +3057,8 @@ function buildForfeitMessage(taskId) {
 function buildSetWithdrawalAddressMessage(withdrawalAddress) {
   return `taskmarket:set-withdrawal-address:${withdrawalAddress.toLowerCase()}`;
 }
-function buildRevealAccountRecoveryCodeMessage(address2) {
-  return `taskmarket:reveal-account-recovery-code:${address2.toLowerCase()}`;
+function buildRevealAccountRecoveryCodeMessage(address3) {
+  return `taskmarket:reveal-account-recovery-code:${address3.toLowerCase()}`;
 }
 function buildWithdrawDreamsMessage(destination, nonce, validBefore) {
   return `taskmarket:withdraw-dreams:${destination.toLowerCase()}:${nonce}:${validBefore}`;
@@ -3033,6 +3066,16 @@ function buildWithdrawDreamsMessage(destination, nonce, validBefore) {
 function buildDeviceRegisterMessage(walletAddress2) {
   return `taskmarket:device-register:${walletAddress2.toLowerCase()}`;
 }
+function buildSponsoredTaskVaultReviewRequestMessage(input2) {
+  return [
+    "Taskmarket: request a Sponsored Task vault curation review",
+    `Vault: ${input2.vaultId.toLowerCase()}`,
+    `Chain: ${input2.chainId}`,
+    `Owner: ${input2.owner.toLowerCase()}`,
+    `Nonce: ${input2.nonce.toLowerCase()}`,
+    `Expires: ${input2.expiresAt}`
+  ].join("\n");
+}
 
 // ../../packages/shared/dist/lib/usdc.js
 var USDC_BASE_UNITS = 10n ** BigInt(USDC_DECIMALS);
@@ -8387,7 +8430,7 @@ async function acquireLock(lockPath) {
       continue;
     if (Date.now() >= deadline)
       throw new Error("Timed out waiting for x402 payment journal lock");
-    await new Promise((resolve) => setTimeout(resolve, 25));
+    await new Promise((resolve2) => setTimeout(resolve2, 25));
   }
 }
 function processIsAlive(pid) {
@@ -10420,13 +10463,13 @@ function x402FundingBalance(records, refunds, key) {
         charged += x402AmountCounted(record);
     }
   }
-  let refunded = 0n;
+  let refunded2 = 0n;
   for (const refund of refunds) {
     if (sameSession(key, refund.railId, refund.sessionKey, refund.network, refund.asset)) {
-      refunded += BigInt(refund.amount);
+      refunded2 += BigInt(refund.amount);
     }
   }
-  const refundable = locked - refunded - charged - pending;
+  const refundable = locked - refunded2 - charged - pending;
   return {
     railId: key.railId,
     sessionKey: key.sessionKey,
@@ -10434,7 +10477,7 @@ function x402FundingBalance(records, refunds, key) {
     asset: key.asset,
     depositing: depositing.toString(),
     locked: locked.toString(),
-    refunded: refunded.toString(),
+    refunded: refunded2.toString(),
     charged: charged.toString(),
     pending: pending.toString(),
     refundable: (refundable > 0n ? refundable : 0n).toString()
@@ -10555,15 +10598,15 @@ function parseX402PayUrl(raw, options = {}) {
     throw invalid("External x402 URL must include a hostname");
   return url;
 }
-function isPrivateIpv4(address2) {
-  const octets = address2.split(".").map(Number);
+function isPrivateIpv4(address3) {
+  const octets = address3.split(".").map(Number);
   if (octets.length !== 4 || octets.some((value) => !Number.isInteger(value)))
     return true;
   const [a, b] = octets;
   return a === 0 || a === 10 || a === 127 || a === 100 && b >= 64 && b <= 127 || a === 169 && b === 254 || a === 172 && b >= 16 && b <= 31 || a === 192 && b === 0 || a === 192 && b === 168 || a === 198 && (b === 18 || b === 19) || a >= 224;
 }
-function isPrivateIpv6(address2) {
-  const normalized = address2.toLowerCase();
+function isPrivateIpv6(address3) {
+  const normalized = address3.toLowerCase();
   if (normalized === "::" || normalized === "::1")
     return true;
   if (normalized.startsWith("fc") || normalized.startsWith("fd"))
@@ -10576,20 +10619,20 @@ function isPrivateIpv6(address2) {
   }
   return false;
 }
-function isPrivateNetworkAddress(address2) {
-  const family = isIP(address2);
+function isPrivateNetworkAddress(address3) {
+  const family = isIP(address3);
   if (family === 4)
-    return isPrivateIpv4(address2);
+    return isPrivateIpv4(address3);
   if (family === 6)
-    return isPrivateIpv6(address2);
+    return isPrivateIpv6(address3);
   return true;
 }
 async function validateX402PayDestination(url, options) {
-  const resolve = options.resolve ?? dns.lookup;
-  const addresses = await resolve(url.hostname, { all: true, verbatim: true });
+  const resolve2 = options.resolve ?? dns.lookup;
+  const addresses = await resolve2(url.hostname, { all: true, verbatim: true });
   if (addresses.length === 0)
     throw new Error(`External x402 host did not resolve: ${url.hostname}`);
-  if (!options.allowPrivateNetwork && addresses.some(({ address: address2 }) => isPrivateNetworkAddress(address2))) {
+  if (!options.allowPrivateNetwork && addresses.some(({ address: address3 }) => isPrivateNetworkAddress(address3))) {
     throw new Error(`External x402 host resolves to a private or reserved address: ${url.hostname}`);
   }
 }
@@ -10621,13 +10664,13 @@ var HOP_BY_HOP_HEADERS = /* @__PURE__ */ new Set([
   "transfer-encoding",
   "upgrade"
 ]);
-function mergeX402RailHeaders(base2, added, options) {
+function mergeX402RailHeaders(base3, added, options) {
   if (added === void 0)
-    return { ...base2 };
+    return { ...base3 };
   if (added === null || typeof added !== "object" || Array.isArray(added)) {
     throw new Error("x402 rail headers must be an object");
   }
-  const merged = { ...base2 };
+  const merged = { ...base3 };
   for (const [name, value] of Object.entries(added)) {
     const normalized = typeof name === "string" ? name.trim().toLowerCase() : "";
     if (!/^[!#$%&'*+.^_`|~0-9a-z-]+$/.test(normalized)) {
@@ -11885,8 +11928,8 @@ async function reconcileX402Payment(input2) {
 }
 
 // ../../packages/x402-payer/dist/payer.js
-function resolveLimits(base2, overrides, lowerOnly) {
-  const result = { ...base2 };
+function resolveLimits(base3, overrides, lowerOnly) {
+  const result = { ...base3 };
   if (overrides === void 0)
     return result;
   if (overrides === null || typeof overrides !== "object") {
@@ -11901,7 +11944,7 @@ function resolveLimits(base2, overrides, lowerOnly) {
         code: "invalid_request"
       });
     }
-    result[key] = lowerOnly ? Math.min(base2[key], value) : value;
+    result[key] = lowerOnly ? Math.min(base3[key], value) : value;
   }
   return result;
 }
@@ -12211,9 +12254,179 @@ function createX402Payer(config) {
   };
 }
 
+// ../../packages/x402-payer/dist/base-channel/runtime.js
+import { z as z68 } from "zod";
+
+// ../../packages/x402-payer/dist/allocations.js
+import { randomUUID as randomUUID6 } from "crypto";
+var COUNT_CAPS = ["turns", "repairs", "tasks", "runtimeSeconds"];
+var WINDOW_CAPS = ["perDay", "perMonth"];
+var CAP_KEYS = /* @__PURE__ */ new Set(["amount", "fees", ...COUNT_CAPS, ...WINDOW_CAPS]);
+
+// ../../packages/x402-payer/dist/base-channel/store.js
+import { createHash as createHash3, randomUUID as randomUUID7 } from "crypto";
+import { hostname as hostname3 } from "os";
+import { resolve } from "path";
+
+// ../../packages/x402-payer/dist/base-channel/wire.js
+import { BATCH_SETTLEMENT_ADDRESS, BATCH_SETTLEMENT_DOMAIN, voucherTypes } from "@x402/evm";
+import { computeChannelId } from "@x402/evm/batch-settlement/client";
+import { getAddress as getAddress4, recoverTypedDataAddress, zeroAddress } from "viem";
+import { z as z67 } from "zod";
+var BASE_CHANNEL_RAIL_ID = "base-batch-channel-v1";
+var PROFILE = "base-batch-channel";
+var BASE_CHANNEL_NETWORKS = ["eip155:8453", "eip155:84532"];
+var WITHDRAW_DELAY_SECONDS = 3600;
+var UINT128_MAX = (1n << 128n) - 1n;
+var ATOMIC = /^(0|[1-9][0-9]{0,38})$/;
+var atomic = z67.string().regex(ATOMIC).refine((v) => ATOMIC.test(v) && BigInt(v) <= UINT128_MAX);
+var positive = atomic.refine((v) => v !== "0");
+var hex32 = z67.string().regex(/^0x[0-9a-fA-F]{64}$/);
+var address2 = z67.string().regex(/^0x[0-9a-fA-F]{40}$/);
+var signature = z67.string().regex(/^0x[0-9a-fA-F]{130}$/);
+var purchaseId = z67.string().regex(/^[A-Za-z0-9:._-]{1,128}$/);
+var networkSchema = z67.enum(BASE_CHANNEL_NETWORKS);
+var seconds = z67.number().int().nonnegative().max(2 ** 40 - 1);
+var channelStateSchema = z67.object({
+  channelId: hex32,
+  balance: atomic,
+  totalClaimed: atomic,
+  withdrawRequestedAt: seconds,
+  refundNonce: z67.string().regex(/^(0|[1-9][0-9]{0,77})$/),
+  chargedCumulativeAmount: atomic
+}).strict();
+var voucherStateSchema = z67.object({ signedMaxClaimable: atomic, signature }).strict();
+var extraSchema = z67.object({
+  name: z67.string().min(1).max(64),
+  version: z67.literal("2"),
+  receiverAuthorizer: address2,
+  withdrawDelay: z67.literal(WITHDRAW_DELAY_SECONDS),
+  assetTransferMethod: z67.literal("eip3009"),
+  minDeposit: positive,
+  maxChannelBalance: positive,
+  paymentProfile: z67.literal(PROFILE),
+  contractVersion: z67.literal(BASE_CHANNEL_RAIL_ID),
+  purchaseId,
+  channelState: channelStateSchema.optional(),
+  voucherState: voucherStateSchema.optional()
+}).strict();
+var requirementSchema = z67.object({
+  scheme: z67.literal("batch-settlement"),
+  network: networkSchema,
+  asset: address2,
+  amount: positive,
+  payTo: address2,
+  maxTimeoutSeconds: z67.number().int().positive().max(120),
+  extra: extraSchema
+}).strict();
+var responseBase = {
+  success: z67.literal(true),
+  transaction: z67.union([z67.literal(""), hex32]),
+  network: networkSchema,
+  payer: address2,
+  amount: z67.union([z67.literal(""), atomic])
+};
+var chargeSchema = z67.object({
+  ...responseBase,
+  extra: z67.object({ purchaseId, chargedAmount: atomic, channelState: channelStateSchema }).strict()
+}).strict();
+var refundSchema = z67.object({
+  ...responseBase,
+  transaction: hex32,
+  amount: positive,
+  extra: z67.object({ channelState: channelStateSchema }).strict()
+}).strict();
+var statusSchema = z67.object({
+  contractVersion: z67.literal(BASE_CHANNEL_RAIL_ID),
+  paymentProfile: z67.literal(PROFILE),
+  network: networkSchema,
+  scheme: z67.literal("batch-settlement"),
+  asset: address2,
+  channelId: hex32,
+  admission: z67.enum(["open", "busy", "withdrawal_pending", "empty", "retired"]),
+  channelState: channelStateSchema,
+  voucherState: voucherStateSchema.nullable(),
+  activePurchase: purchaseId.nullable(),
+  lastCommit: z67.object({ purchaseId, chargedAmount: atomic, chargedCumulativeAmount: atomic }).strict().nullable(),
+  unclaimed: atomic,
+  onchainSyncedAt: seconds
+}).strict();
+
+// ../../packages/x402-payer/dist/base-channel/runtime.js
+var purchaseStatusSchema = z68.object({
+  purchase_id: z68.string(),
+  payment: z68.enum([
+    "awaiting_payment",
+    "pending",
+    "verified",
+    "zero_charge",
+    "collection_failed",
+    "unresolved"
+  ]),
+  inference: z68.enum([
+    "awaiting_payment",
+    "admitted",
+    "dispatch_claimed",
+    "running",
+    "completion_committed",
+    "zero_charge",
+    "unresolved"
+  ]),
+  delivery: z68.string(),
+  result_replay_available: z68.literal(false)
+}).strict();
+var depositDataSchema = z68.object({
+  nonce: hex32,
+  amount: z68.string(),
+  validBefore: z68.number(),
+  afterBlock: z68.string().optional()
+});
+var paymentDataSchema = z68.object({
+  purchaseId: z68.string(),
+  statusToken: z68.string(),
+  chargedBefore: z68.string(),
+  maximum: z68.string(),
+  sequence: z68.number(),
+  refused: z68.boolean(),
+  deposit: depositDataSchema.nullable()
+});
+
+// ../../packages/x402-payer/dist/base-channel/rail.js
+import { createBatchSettlementEIP3009DepositPayload, signVoucher } from "@x402/evm/batch-settlement/client";
+
+// ../../packages/x402-payer/dist/base-channel/lifecycle.js
+import { BATCH_SETTLEMENT_ADDRESS as BATCH_SETTLEMENT_ADDRESS3 } from "@x402/evm";
+import { signVoucher as signVoucher2 } from "@x402/evm/batch-settlement/client";
+import { encodeFunctionData as encodeFunctionData2, keccak256, parseTransaction, recoverTransactionAddress } from "viem";
+
+// ../../packages/x402-payer/dist/base-channel/rpc.js
+import { BATCH_SETTLEMENT_ADDRESS as BATCH_SETTLEMENT_ADDRESS2, ERC3009_DEPOSIT_COLLECTOR_ADDRESS } from "@x402/evm";
+import { createPublicClient as createPublicClient3, decodeEventLog, http as http3, parseAbi, parseAbiItem } from "viem";
+import { base as base2, baseSepolia as baseSepolia2 } from "viem/chains";
+var CHANNEL_CONFIG_TUPLE = "(address payer,address payerAuthorizer,address receiver,address receiverAuthorizer,address token,uint40 withdrawDelay,bytes32 salt)";
+var channelAbi = parseAbi([
+  "function channels(bytes32) view returns (uint128 balance,uint128 totalClaimed)",
+  "function pendingWithdrawals(bytes32) view returns (uint128 amount,uint40 initiatedAt)",
+  "function refundNonce(bytes32) view returns (uint256)",
+  `function initiateWithdraw(${CHANNEL_CONFIG_TUPLE} config,uint128 amount)`,
+  `function finalizeWithdraw(${CHANNEL_CONFIG_TUPLE} config)`
+]);
+var tokenAbi = parseAbi([
+  "function authorizationState(address,bytes32) view returns (bool)",
+  "event Transfer(address indexed from,address indexed to,uint256 value)",
+  "event AuthorizationUsed(address indexed authorizer,bytes32 indexed nonce)"
+]);
+var deposited = parseAbiItem("event Deposited(bytes32 indexed channelId,address indexed sender,uint128 amount,uint128 newBalance)");
+var refunded = parseAbiItem("event Refunded(bytes32 indexed channelId,address indexed sender,uint128 amount)");
+var withdrawn = parseAbiItem("event WithdrawFinalized(bytes32 indexed channelId,address indexed sender,uint128 amount)");
+var gasPriceOracleAbi = parseAbi([
+  "function getL1Fee(bytes data) view returns (uint256)",
+  "function getOperatorFee(uint256 gasUsed) view returns (uint256)"
+]);
+
 // ../../packages/x402-payer/dist/taskmarket-fee-rail.js
 import { randomBytes as randomBytes2 } from "crypto";
-import { getAddress as getAddress4, toHex } from "viem";
+import { getAddress as getAddress5, toHex } from "viem";
 var TASKMARKET_FEE_RAIL_ID = "taskmarket-fee";
 var TRANSFER_WITH_AUTHORIZATION = [
   { name: "from", type: "address" },
@@ -12234,7 +12447,7 @@ async function signTaskmarketFeePayment(input2) {
     validBefore: String(now + requirement.maxTimeoutSeconds),
     nonce: toHex(randomBytes2(32))
   };
-  const signature = await input2.signTypedData({
+  const signature2 = await input2.signTypedData({
     domain: input2.typedData.domain,
     types: input2.typedData.types,
     primaryType: input2.typedData.primaryType,
@@ -12252,7 +12465,7 @@ async function signTaskmarketFeePayment(input2) {
       maxTimeoutSeconds: requirement.maxTimeoutSeconds,
       extra: requirement.extra
     },
-    payload: { authorization, signature }
+    payload: { authorization, signature: signature2 }
   };
   return { header: Buffer.from(JSON.stringify(payload)).toString("base64"), authorization };
 }
@@ -12330,7 +12543,7 @@ function createTaskmarketFeeRail() {
         resource: paymentRequired.resource,
         requirement,
         typedData,
-        from: getAddress4(account.address),
+        from: getAddress5(account.address),
         signTypedData: (data) => account.signTypedData(data)
       });
       return {
@@ -12366,12 +12579,6 @@ function createTaskmarketFeeRail() {
   };
 }
 
-// ../../packages/x402-payer/dist/allocations.js
-import { randomUUID as randomUUID6 } from "crypto";
-var COUNT_CAPS = ["turns", "repairs", "tasks", "runtimeSeconds"];
-var WINDOW_CAPS = ["perDay", "perMonth"];
-var CAP_KEYS = /* @__PURE__ */ new Set(["amount", "fees", ...COUNT_CAPS, ...WINDOW_CAPS]);
-
 // src/lib/output.ts
 function printResult(data, options) {
   const idempotencyKey = options?.idempotencyKey;
@@ -12422,13 +12629,13 @@ function printWarning(message) {
 }
 
 // src/lib/agent.ts
-async function pollAgentId(address2, maxWaitMs = 6e4) {
+async function pollAgentId(address3, maxWaitMs = 6e4) {
   const interval = 3e3;
   const deadline = Date.now() + maxWaitMs;
   while (Date.now() < deadline) {
     await new Promise((r) => setTimeout(r, interval));
     try {
-      const res = await fetch(`${API_URL}/api/identity/status?address=${address2}`);
+      const res = await fetch(`${API_URL}/api/identity/status?address=${address3}`);
       if (res.ok) {
         const data = await res.json();
         if (data.agentId) return data.agentId;
@@ -12537,8 +12744,8 @@ import { createInterface } from "readline/promises";
 // src/lib/signer.ts
 import { privateKeyToAccount as privateKeyToAccount2 } from "viem/accounts";
 async function fetchDeviceKey(deviceId, apiToken, keyServerUrl) {
-  const base2 = keyServerUrl ?? API_URL;
-  const res = await fetch(`${base2}/api/devices/${deviceId}/key`, {
+  const base3 = keyServerUrl ?? API_URL;
+  const res = await fetch(`${base3}/api/devices/${deviceId}/key`, {
     method: "POST",
     headers: { "Content-Type": "application/json" },
     body: JSON.stringify({ deviceId, apiToken })
@@ -12650,14 +12857,14 @@ async function acceptLegalBundle(options) {
     })).data
   );
   validateLegalChallenge(bundle, challenge, options.walletAddress);
-  const signature = await options.signMessage(challenge.message);
+  const signature2 = await options.signMessage(challenge.message);
   const result = LegalAcceptanceResponseSchema.parse(
     (await apiPost("/api/legal/accept/wallet", {
       ...affirmations,
       bundleDigest: bundle.bundleDigest,
       bundleVersion: bundle.version,
       nonce: challenge.nonce,
-      signature,
+      signature: signature2,
       walletAddress: options.walletAddress
     })).data
   );
@@ -12724,9 +12931,9 @@ legalCommand.addCommand(acceptCommand);
 function sanitizeEmailUsername(agentId, suffix) {
   const maxBase = 30 - 1 - suffix.length;
   if (maxBase < 2) return null;
-  const base2 = agentId.toLowerCase().replace(/[^a-z0-9]/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "").slice(0, maxBase).replace(/-+$/, "");
-  if (base2.length < 2) return null;
-  const candidate = `${base2}-${suffix}`;
+  const base3 = agentId.toLowerCase().replace(/[^a-z0-9]/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "").slice(0, maxBase).replace(/-+$/, "");
+  if (base3.length < 2) return null;
+  const candidate = `${base3}-${suffix}`;
   return /^[a-z0-9][a-z0-9-]{1,28}[a-z0-9]$/.test(candidate) ? candidate : null;
 }
 async function tryRegisterEmail(deviceId, apiToken, username, explicit) {
@@ -12804,18 +13011,18 @@ var initCommand = new Command2("init").description("Create and register a new ag
     });
     return;
   }
-  const { privateKey, address: address2 } = generateKeypair();
+  const { privateKey, address: address3 } = generateKeypair();
   const publicKey = deriveCompressedPublicKey(privateKey);
   const legalBundle = LegalBundleSchema.parse(await apiGet("/api/legal/current"));
   const legalAcceptance = legalBundle.enforcementEnabled ? await acceptLegalBundle({
     assumeYes: Boolean(opts.yes),
     bundle: legalBundle,
     signMessage: (message) => privateKeyToAccount3(privateKey).signMessage({ message }),
-    walletAddress: address2
+    walletAddress: address3
   }) : void 0;
   const deviceRegisterSignature = await privateKeyToAccount3(
     privateKey
-  ).signMessage({ message: buildDeviceRegisterMessage(address2) });
+  ).signMessage({ message: buildDeviceRegisterMessage(address3) });
   const {
     deviceId,
     apiToken,
@@ -12825,13 +13032,13 @@ var initCommand = new Command2("init").description("Create and register a new ag
     legalReceipt: legalAcceptance?.receipt,
     publicKey,
     signature: deviceRegisterSignature,
-    walletAddress: address2
+    walletAddress: address3
   });
   const encryptedKey = encryptPrivateKey(deviceEncryptionKey, privateKey);
   let agentId = initialAgentId;
   await saveKeystore({
     encryptedKey,
-    walletAddress: address2,
+    walletAddress: address3,
     deviceId,
     apiToken,
     agentId,
@@ -12843,7 +13050,7 @@ var initCommand = new Command2("init").description("Create and register a new ag
     } : {}
   });
   if (!agentId) {
-    agentId = await pollAgentId(address2);
+    agentId = await pollAgentId(address3);
     if (agentId) {
       const keystore = await loadKeystore();
       await saveKeystore({ ...keystore, agentId });
@@ -12858,7 +13065,7 @@ var initCommand = new Command2("init").description("Create and register a new ag
   const username = opts.email ?? (agentId && networkInfo ? sanitizeEmailUsername(agentId, String(networkInfo.chainId)) : null);
   const emailAddress = username ? await tryRegisterEmail(deviceId, apiToken, username, !!opts.email) : null;
   printResult({
-    address: address2,
+    address: address3,
     agentId,
     network: networkInfo?.networkName,
     chainId: networkInfo?.chainId,
@@ -12963,16 +13170,16 @@ identityCommand.command("status").description("Check identity registration statu
 // src/commands/stats.ts
 import { Command as Command5 } from "commander";
 var statsCommand = new Command5("stats").description("View agent statistics").option("--address <addr>", "Wallet address (defaults to own wallet)").option("--agent <agentId>", "Agent ID (alternative to --address)").action(async (opts) => {
-  let address2 = opts.address;
-  if (!address2) {
+  let address3 = opts.address;
+  if (!address3) {
     const keystore = await loadKeystore();
-    address2 = keystore.walletAddress;
+    address3 = keystore.walletAddress;
   }
-  const statsQuery = opts.agent ? `/api/agents/stats?agentId=${opts.agent}` : `/api/agents/stats?address=${address2}`;
+  const statsQuery = opts.agent ? `/api/agents/stats?agentId=${opts.agent}` : `/api/agents/stats?address=${address3}`;
   const [result, balanceResult, dreamsResult, exchangeRateResult] = await Promise.all([
     apiGet(statsQuery),
-    apiGet(`/api/wallet/balance?address=${address2}`),
-    apiGet(`/api/wallet/dreams-balance?address=${address2}`).then((r) => r).catch(() => null),
+    apiGet(`/api/wallet/balance?address=${address3}`),
+    apiGet(`/api/wallet/dreams-balance?address=${address3}`).then((r) => r).catch(() => null),
     apiGet("/api/wallet/exchange-rate").then((r) => r).catch(() => null)
   ]);
   let pendingDreamsRewards = null;
@@ -13013,6 +13220,25 @@ import { Command as Command41 } from "commander";
 // src/commands/task/create.ts
 import { Command as Command6 } from "commander";
 import { parseUnits } from "viem";
+function parseStakeOptions(opts) {
+  if (!opts.stakeRequired && opts.stakeBps === void 0) {
+    return { stakeRequired: false, stakeBps: 0 };
+  }
+  if (opts.mode !== "claim") {
+    return { error: "--stake-required and --stake-bps are only valid with --mode claim" };
+  }
+  if (!opts.stakeRequired) {
+    return { error: "--stake-bps requires --stake-required" };
+  }
+  if (opts.stakeBps === void 0) {
+    return { stakeRequired: true, stakeBps: 0 };
+  }
+  const stakeBps = Number(opts.stakeBps);
+  if (!/^\d+$/.test(opts.stakeBps.trim()) || stakeBps > 1e4) {
+    return { error: "--stake-bps must be an integer between 0 and 10000" };
+  }
+  return { stakeRequired: true, stakeBps };
+}
 var createCmd = new Command6("create").description("Create a new task (costs reward amount in USDC)").requiredOption("--description <text>", "Task description").requiredOption("--reward <usdc>", "Reward in USDC (e.g. 5 for 5 USDC)").requiredOption("--duration <hours>", "Task duration in hours").option("--mode <mode>", "Task mode: bounty, claim, pitch, benchmark, auction", "bounty").option(
   "--task-visibility <mode>",
   "Task visibility: public (default), unlisted, or private. Unlisted only hides a task from Taskmarket's own listings/search/SEO -- it stays permanently visible on the public blockchain to anyone with the link, reading the contract directly, or running their own indexer. private is genuinely access-controlled: only the requester and invited/assigned workers can view it via listings, get, or the gated reads -- see --allowed-viewers and --access-password. Even private, the on-chain existence, reward, and participation stay publicly observable regardless.",
@@ -13050,6 +13276,12 @@ var createCmd = new Command6("create").description("Create a new task (costs rew
 ).option(
   "--sponsored-task-tokens <amount>",
   "Whole-token amount to reserve from the --sponsored-task vault (e.g. 100 for 100 tokens). Required with --sponsored-task."
+).option(
+  "--stake-required",
+  "Require the worker who claims the task to stake a share of the reward first (claim mode only)"
+).option(
+  "--stake-bps <bps>",
+  "Stake as basis points of the reward, 0-10000 (e.g. 1000 = 10%). Requires --stake-required."
 ).option("--evaluator <address>", "Evaluator address (optional)").option("--evaluator-fee-bps <bps>", "Evaluator fee in basis points (optional)").option("--evaluation-window <hours>", "Evaluation window in hours (default: 24)").option("--appeal-window <hours>", "Appeal window in hours (default: 24)").option("--dispute-resolver <address>", "Dispute resolver address (optional)").action(
   async (opts) => {
     let rewardBaseUnits;
@@ -13126,6 +13358,10 @@ var createCmd = new Command6("create").description("Create a new task (costs rew
         );
       }
     }
+    const stake = parseStakeOptions(opts);
+    if ("error" in stake) {
+      return void printError(stake.error);
+    }
     const tags = opts.tags ? opts.tags.split(",").map((t) => t.trim()) : [];
     const body = {
       description: opts.description,
@@ -13135,8 +13371,8 @@ var createCmd = new Command6("create").description("Create a new task (costs rew
       taskVisibility: opts.taskVisibility,
       submissionVisibility: opts.submissionVisibility,
       tags,
-      stakeRequired: false,
-      stakeBps: 0
+      stakeRequired: stake.stakeRequired,
+      stakeBps: stake.stakeBps
     };
     if (allowedViewers && allowedViewers.length > 0) {
       body.allowedViewers = allowedViewers;
@@ -13255,8 +13491,8 @@ var createCmd = new Command6("create").description("Create a new task (costs rew
           pitchDeadline: opts.pitchDeadline ? parseInt(opts.pitchDeadline, 10) * 3600 : void 0,
           bidDeadline: opts.bidDeadline ? parseInt(opts.bidDeadline, 10) : void 0,
           auctionType: opts.auctionType,
-          stakeRequired: false,
-          stakeBps: 0,
+          stakeRequired: stake.stakeRequired,
+          stakeBps: stake.stakeBps,
           tags: opts.tags ? opts.tags.split(",").map((t) => t.trim()) : [],
           hookContracts: hooks,
           evaluator: opts.evaluator,
@@ -13353,14 +13589,14 @@ async function signReadAuth() {
   }
   try {
     const account = await createWalletAccountFromKeystore(keystore);
-    const signature = await account.signMessage({
+    const signature2 = await account.signMessage({
       message: buildReadAuthMessage(keystore.walletAddress)
     });
     return {
       walletAddress: keystore.walletAddress,
       headers: {
         [READ_AUTH_ADDRESS_HEADER]: keystore.walletAddress,
-        [READ_AUTH_SIGNATURE_HEADER]: signature
+        [READ_AUTH_SIGNATURE_HEADER]: signature2
       }
     };
   } catch {
@@ -13455,20 +13691,20 @@ var getCmd = new Command8("get").description("Get task details").argument("<task
 import { Command as Command9, Option } from "commander";
 import { promises as fsPromises } from "fs";
 import { basename, extname } from "path";
-import { createHash as createHash4 } from "crypto";
+import { createHash as createHash5 } from "crypto";
 import { Readable } from "stream";
 import https from "https";
-import http3 from "http";
-import { keccak256 } from "viem";
+import http4 from "http";
+import { keccak256 as keccak2562 } from "viem";
 
 // src/lib/x402-fee.ts
-import { randomUUID as randomUUID9 } from "crypto";
+import { randomUUID as randomUUID10 } from "crypto";
 
 // src/lib/x402-pay-client.ts
-import { randomUUID as randomUUID8 } from "crypto";
+import { randomUUID as randomUUID9 } from "crypto";
 
 // src/lib/x402-http.ts
-import { createHash as createHash3, randomUUID as randomUUID7 } from "crypto";
+import { createHash as createHash4, randomUUID as randomUUID8 } from "crypto";
 import { promises as fs6 } from "fs";
 import path8 from "path";
 async function loadExternalHeaders(input2) {
@@ -13573,7 +13809,7 @@ async function readX402RequestBody(input2) {
 async function writeExclusiveAtomic(outputPath, bytes2) {
   const directory = path8.dirname(outputPath);
   await fs6.mkdir(directory, { recursive: true });
-  const temporaryPath = path8.join(directory, `.${path8.basename(outputPath)}-${randomUUID7()}.tmp`);
+  const temporaryPath = path8.join(directory, `.${path8.basename(outputPath)}-${randomUUID8()}.tmp`);
   try {
     await fs6.writeFile(temporaryPath, bytes2, { flag: "wx", mode: 384 });
     await fs6.link(temporaryPath, outputPath);
@@ -13590,7 +13826,7 @@ async function writeExclusiveAtomic(outputPath, bytes2) {
 async function externalResponseData(response, options = {}) {
   const bytes2 = response instanceof Response ? new Uint8Array(await response.arrayBuffer()) : response.body;
   const contentType = response instanceof Response ? response.headers.get("content-type") ?? "application/octet-stream" : response.contentType;
-  const sha2562 = createHash3("sha256").update(bytes2).digest("hex");
+  const sha2562 = createHash4("sha256").update(bytes2).digest("hex");
   if (options.outputPath) {
     await writeExclusiveAtomic(options.outputPath, bytes2);
     return {
@@ -13679,7 +13915,7 @@ async function executeX402PayRequest(options) {
   const result = await payer.request(
     {
       apiVersion: 1,
-      invocationId: options.invocationId ?? randomUUID8(),
+      invocationId: options.invocationId ?? randomUUID9(),
       url: options.rawUrl,
       method,
       headers: options.headers,
@@ -13772,7 +14008,7 @@ async function x402FeePost(path11, body, options = {}) {
         apiVersion: 1,
         // A fresh invocation per run: the backend recognises a repeated write by its idempotency
         // key, so a re-run must reach it rather than be answered from the local journal.
-        invocationId: randomUUID9(),
+        invocationId: randomUUID10(),
         url: request.url,
         method: "POST",
         headers: request.headers,
@@ -13847,9 +14083,9 @@ function mimeTypeForPath(filePath) {
   }
 }
 function streamingPut(uploadUrl, data, mimeType, label) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     const url = new URL(uploadUrl);
-    const transport = url.protocol === "https:" ? https : http3;
+    const transport = url.protocol === "https:" ? https : http4;
     const req = transport.request(
       url,
       {
@@ -13865,7 +14101,7 @@ function streamingPut(uploadUrl, data, mimeType, label) {
         res.on("end", () => {
           if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
             process.stderr.write("\n");
-            resolve();
+            resolve2();
           } else {
             const body = Buffer.concat(chunks).toString("utf8").slice(0, 500);
             reject(
@@ -13899,7 +14135,7 @@ var submitCmd = new Command9("submit").description("Submit work for a task").arg
     }
     const submissionKey = resolveIdempotencyKey();
     const keystore = await loadKeystore();
-    const signature = await signMessage(buildSubmitMessage(taskId), keystore);
+    const signature2 = await signMessage(buildSubmitMessage(taskId), keystore);
     const artifactInputs = await Promise.all(
       opts.file.map(async (filePath) => {
         const mimeType = mimeTypeForPath(filePath);
@@ -13914,15 +14150,15 @@ var submitCmd = new Command9("submit").description("Submit work for a task").arg
           {
             taskId,
             workerAddress: keystore.walletAddress,
-            signature,
+            signature: signature2,
             fileName: basename(filePath),
             mimeType,
             role: opts.role,
             sizeBytes: data.length
           }
         );
-        const sha256Hash = createHash4("sha256").update(data).digest("hex");
-        const keccak256Hash = keccak256(new Uint8Array(data));
+        const sha256Hash = createHash5("sha256").update(data).digest("hex");
+        const keccak256Hash = keccak2562(new Uint8Array(data));
         process.stderr.write(`  Uploading ${basename(filePath)}...
 `);
         await streamingPut(uploadUrl, data, mimeType, basename(filePath));
@@ -14057,12 +14293,12 @@ import { Command as Command13 } from "commander";
 var claimCmd = new Command13("claim").description("Claim a task as a worker").argument("<taskId>", "Task ID (0x-prefixed hex)").action(async (taskId) => {
   const keystore = await loadKeystore();
   const message = buildClaimMessage(taskId);
-  const signature = await signMessage(message, keystore);
+  const signature2 = await signMessage(message, keystore);
   const { data: result, idempotencyKey } = await apiPost(
     `/api/tasks/${taskId}/claim`,
     {
       workerAddress: keystore.walletAddress,
-      signature
+      signature: signature2
     }
   );
   printResult({ claimId: result.claimId }, { idempotencyKey });
@@ -14072,7 +14308,7 @@ var claimCmd = new Command13("claim").description("Claim a task as a worker").ar
 import { Command as Command14 } from "commander";
 var pitchCmd = new Command14("pitch").description("Submit a pitch for a task (costs 0.001 USDC, anchors hash on-chain)").argument("<taskId>", "Task ID (0x-prefixed hex)").requiredOption("--text <text>", "Pitch text").option("--duration <hours>", "Estimated duration in hours").action(async (taskId, opts) => {
   const keystore = await loadKeystore();
-  const signature = await signMessage(`taskmarket:pitch:${taskId}`, keystore);
+  const signature2 = await signMessage(`taskmarket:pitch:${taskId}`, keystore);
   const { data: result, idempotencyKey } = await x402Post(
     `/api/tasks/${taskId}/pitches`,
     {
@@ -14080,7 +14316,7 @@ var pitchCmd = new Command14("pitch").description("Submit a pitch for a task (co
       workerAddress: keystore.walletAddress,
       pitchText: opts.text,
       ...opts.duration ? { estimatedDuration: parseInt(opts.duration, 10) } : {},
-      signature
+      signature: signature2
     }
   );
   printResult({ pitchId: result.pitchId }, { idempotencyKey });
@@ -14103,12 +14339,12 @@ import { Command as Command16 } from "commander";
 var selectWorkerCmd = new Command16("select-worker").description("Select a worker from pitches (requester only)").argument("<taskId>", "Task ID (0x-prefixed hex)").requiredOption("--pitch <pitchId>", "Pitch ID to select").requiredOption("--worker <address>", "Worker wallet address to assign").action(async (taskId, opts) => {
   const keystore = await loadKeystore();
   const message = buildSelectWorkerMessage(taskId, opts.pitch, opts.worker);
-  const signature = await signMessage(message, keystore);
+  const signature2 = await signMessage(message, keystore);
   const { idempotencyKey } = await x402Post(`/api/tasks/${taskId}/pitches/select`, {
     taskId,
     pitchId: opts.pitch,
     workerAddress: opts.worker,
-    signature
+    signature: signature2
   });
   printResult({ selected: true }, { idempotencyKey });
 });
@@ -14117,14 +14353,14 @@ var selectWorkerCmd = new Command16("select-worker").description("Select a worke
 import { Command as Command17 } from "commander";
 var proofCmd = new Command17("proof").description("Submit a benchmark proof (costs 0.001 USDC, anchors hash on-chain)").argument("<taskId>", "Task ID (0x-prefixed hex)").requiredOption("--data <data>", "Proof data").requiredOption("--type <type>", "Proof type").option("--metric <val>", "Metric value").action(async (taskId, opts) => {
   const keystore = await loadKeystore();
-  const signature = await signMessage(`taskmarket:proof:${taskId}`, keystore);
+  const signature2 = await signMessage(`taskmarket:proof:${taskId}`, keystore);
   const { data: result, idempotencyKey } = await x402Post(`/api/tasks/${taskId}/proofs`, {
     taskId,
     workerAddress: keystore.walletAddress,
     proofData: opts.data,
     proofType: opts.type,
     ...opts.metric ? { metricValue: opts.metric } : {},
-    signature
+    signature: signature2
   });
   printResult({ proofId: result.proofId, submissionId: result.submissionId }, { idempotencyKey });
 });
@@ -14404,12 +14640,12 @@ import { Command as Command28 } from "commander";
 var mySubmissionsCmd = new Command28("my-submissions").description("List all submissions made by your wallet across all tasks.").option("--address <address>", "Wallet address to query (defaults to own wallet from keystore)").action(async (opts) => {
   try {
     const auth = await signReadAuth();
-    const address2 = opts.address ?? auth?.walletAddress;
-    if (!address2) {
+    const address3 = opts.address ?? auth?.walletAddress;
+    if (!address3) {
       throw new Error("No address provided and no keystore found -- pass --address <address>.");
     }
     const result = await apiGet(
-      `/api/submissions/mine?workerAddress=${encodeURIComponent(address2)}`,
+      `/api/submissions/mine?workerAddress=${encodeURIComponent(address3)}`,
       { headers: auth?.headers ?? {} }
     );
     printResult(result);
@@ -14513,13 +14749,13 @@ var forfeitCmd = new Command30("forfeit").description("Reclaim a claim-mode task
   try {
     const keystore = await loadKeystore();
     const message = buildForfeitMessage(taskId);
-    const signature = await signMessage(message, keystore);
+    const signature2 = await signMessage(message, keystore);
     const { data: result, idempotencyKey } = await apiPost(
       `/api/tasks/${taskId}/forfeit`,
       {
         taskId,
         requesterAddress: keystore.walletAddress,
-        signature
+        signature: signature2
       }
     );
     printResult(result, { idempotencyKey });
@@ -14739,7 +14975,7 @@ var unlockCmd = new Command37("unlock").description("Unlock a private task with
 
 // src/commands/task/invite.ts
 import { Command as Command38 } from "commander";
-var inviteCmd = new Command38("invite").description("Invite a wallet to view a private task (requester only)").argument("<taskId>", "Task ID (0x-prefixed hex)").argument("<address>", "Wallet address to invite").action(async (taskId, address2) => {
+var inviteCmd = new Command38("invite").description("Invite a wallet to view a private task (requester only)").argument("<taskId>", "Task ID (0x-prefixed hex)").argument("<address>", "Wallet address to invite").action(async (taskId, address3) => {
   const auth = await signReadAuth();
   if (!auth || Object.keys(auth.headers).length === 0) {
     printError("No keystore found. Run `taskmarket init` first.");
@@ -14748,7 +14984,7 @@ var inviteCmd = new Command38("invite").description("Invite a wallet to view a p
   try {
     const { data: result, idempotencyKey } = await apiPost(
       `/api/tasks/${taskId}/private-access/viewers`,
-      { taskId, viewerAddress: address2 },
+      { taskId, viewerAddress: address3 },
       { headers: auth.headers }
     );
     printResult(result, { idempotencyKey });
@@ -14759,7 +14995,7 @@ var inviteCmd = new Command38("invite").description("Invite a wallet to view a p
 
 // src/commands/task/uninvite.ts
 import { Command as Command39 } from "commander";
-var uninviteCmd = new Command39("uninvite").description("Remove a wallet from a private task's allowlist (requester only)").argument("<taskId>", "Task ID (0x-prefixed hex)").argument("<address>", "Wallet address to remove").action(async (taskId, address2) => {
+var uninviteCmd = new Command39("uninvite").description("Remove a wallet from a private task's allowlist (requester only)").argument("<taskId>", "Task ID (0x-prefixed hex)").argument("<address>", "Wallet address to remove").action(async (taskId, address3) => {
   const auth = await signReadAuth();
   if (!auth || Object.keys(auth.headers).length === 0) {
     printError("No keystore found. Run `taskmarket init` first.");
@@ -14767,7 +15003,7 @@ var uninviteCmd = new Command39("uninvite").description("Remove a wallet from a
   }
   try {
     const { data: result, idempotencyKey } = await apiDelete(
-      `/api/tasks/${taskId}/private-access/viewers/${encodeURIComponent(address2)}`,
+      `/api/tasks/${taskId}/private-access/viewers/${encodeURIComponent(address3)}`,
       { headers: auth.headers }
     );
     printResult(result, { idempotencyKey });
@@ -14852,9 +15088,9 @@ var inboxCommand = new Command43("inbox").description("Show tasks you created an
     printError("No keystore found. Run `taskmarket init` first.");
     return;
   }
-  const address2 = auth.walletAddress;
+  const address3 = auth.walletAddress;
   const hasReadAuth = Object.keys(auth.headers).length > 0;
-  const inboxParams = new URLSearchParams({ address: address2 });
+  const inboxParams = new URLSearchParams({ address: address3 });
   const [taskResult, pendingBids] = await Promise.all([
     apiGet(`/api/agents/inbox?${inboxParams.toString()}`, {
       headers: auth.headers
@@ -14884,9 +15120,9 @@ var actionsCommand = new Command44("actions").description("Show lifecycle action
 // src/commands/deposit.ts
 import { Command as Command45 } from "commander";
 var depositCommand = new Command45("deposit").description("Show wallet address and network info for funding").action(async () => {
-  let address2;
+  let address3;
   try {
-    address2 = await getWalletAddress();
+    address3 = await getWalletAddress();
   } catch (err) {
     renderFailure(err, { fallback: "No keystore found. Run `taskmarket init` first." });
     return;
@@ -14900,7 +15136,7 @@ var depositCommand = new Command45("deposit").description("Show wallet address a
     return;
   }
   const data = {
-    address: address2,
+    address: address3,
     network: networkInfo.networkName,
     chainId: networkInfo.chainId,
     currency: "USDC",
@@ -14915,12 +15151,12 @@ import { Command as Command54 } from "commander";
 // src/commands/wallet/balance.ts
 import { Command as Command46 } from "commander";
 var walletBalanceCommand = new Command46("balance").description("Show USDC balance").option("--address <addr>", "Address to check (defaults to own wallet)").action(async (opts) => {
-  let address2 = opts.address;
-  if (!address2) {
+  let address3 = opts.address;
+  if (!address3) {
     const keystore = await loadKeystore();
-    address2 = keystore.walletAddress;
+    address3 = keystore.walletAddress;
   }
-  const result = await apiGet(`/api/wallet/balance?address=${address2}`);
+  const result = await apiGet(`/api/wallet/balance?address=${address3}`);
   printResult(result);
 });
 
@@ -14936,7 +15172,7 @@ function normalizePrivateKey(raw) {
   return `0x${hex}`;
 }
 function promptHiddenInput(prompt) {
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     const rl = createInterface2({
       input: process.stdin,
       output: process.stdout,
@@ -14956,7 +15192,7 @@ function promptHiddenInput(prompt) {
       muted.muted = false;
       process.stdout.write("\n");
       rl.close();
-      resolve(answer);
+      resolve2(answer);
     });
   });
 }
@@ -14983,17 +15219,17 @@ var walletImportCommand = new Command47("import").description("Import an existin
   }
   const privateKey = normalizePrivateKey(rawKey);
   const account = privateKeyToAccount4(privateKey);
-  const address2 = account.address;
+  const address3 = account.address;
   const publicKey = deriveCompressedPublicKey(privateKey);
   const legalBundle = LegalBundleSchema.parse(await apiGet("/api/legal/current"));
   const legalAcceptance = legalBundle.enforcementEnabled ? await acceptLegalBundle({
     assumeYes: Boolean(opts.yes),
     bundle: legalBundle,
     signMessage: (message) => account.signMessage({ message }),
-    walletAddress: address2
+    walletAddress: address3
   }) : void 0;
   const deviceRegisterSignature = await account.signMessage({
-    message: buildDeviceRegisterMessage(address2)
+    message: buildDeviceRegisterMessage(address3)
   });
   const {
     deviceId,
@@ -15004,13 +15240,13 @@ var walletImportCommand = new Command47("import").description("Import an existin
     legalReceipt: legalAcceptance?.receipt,
     publicKey,
     signature: deviceRegisterSignature,
-    walletAddress: address2
+    walletAddress: address3
   });
   const encryptedKey = encryptPrivateKey(deviceEncryptionKey, privateKey);
   let agentId = initialAgentId;
   await saveKeystore({
     encryptedKey,
-    walletAddress: address2,
+    walletAddress: address3,
     deviceId,
     apiToken,
     agentId,
@@ -15022,7 +15258,7 @@ var walletImportCommand = new Command47("import").description("Import an existin
     } : {}
   });
   if (!agentId) {
-    agentId = await pollAgentId(address2);
+    agentId = await pollAgentId(address3);
     if (agentId) {
       const keystore = await loadKeystore();
       await saveKeystore({ ...keystore, agentId });
@@ -15035,7 +15271,7 @@ var walletImportCommand = new Command47("import").description("Import an existin
       }) + "\n"
     );
   }
-  printResult({ address: address2, agentId });
+  printResult({ address: address3, agentId });
 });
 
 // src/commands/wallet/set-withdrawal-address.ts
@@ -15043,8 +15279,8 @@ import { Command as Command48 } from "commander";
 function isValidAddress(addr) {
   return /^0x[a-fA-F0-9]{40}$/.test(addr);
 }
-var setWithdrawalAddressCommand = new Command48("set-withdrawal-address").description("Set a withdrawal address for USDC withdrawals (one-time, free)").argument("<address>", "Ethereum address to receive withdrawals").action(async (address2) => {
-  if (!isValidAddress(address2)) {
+var setWithdrawalAddressCommand = new Command48("set-withdrawal-address").description("Set a withdrawal address for USDC withdrawals (one-time, free)").argument("<address>", "Ethereum address to receive withdrawals").action(async (address3) => {
+  if (!isValidAddress(address3)) {
     printError("Invalid Ethereum address: must be 0x followed by 40 hex characters");
     return;
   }
@@ -15056,12 +15292,12 @@ var setWithdrawalAddressCommand = new Command48("set-withdrawal-address").descri
     return;
   }
   const walletAddress2 = keystore.walletAddress;
-  const message = buildSetWithdrawalAddressMessage(address2);
-  const signature = await signMessage(message, keystore);
+  const message = buildSetWithdrawalAddressMessage(address3);
+  const signature2 = await signMessage(message, keystore);
   const { data: result, idempotencyKey } = await apiPost("/api/wallet/set-withdrawal-address", {
     walletAddress: walletAddress2,
-    withdrawalAddress: address2,
-    signature
+    withdrawalAddress: address3,
+    signature: signature2
   });
   printResult(
     {
@@ -15076,12 +15312,12 @@ var setWithdrawalAddressCommand = new Command48("set-withdrawal-address").descri
 // src/commands/wallet/get-withdrawal-address.ts
 import { Command as Command49 } from "commander";
 var getWithdrawalAddressCommand = new Command49("get-withdrawal-address").description("Show the currently registered withdrawal address, if any").option("--address <addr>", "Wallet address to check (defaults to own wallet)").action(async (opts) => {
-  let address2 = opts.address;
-  if (!address2) {
+  let address3 = opts.address;
+  if (!address3) {
     const keystore = await loadKeystore();
-    address2 = keystore.walletAddress;
+    address3 = keystore.walletAddress;
   }
-  const result = await apiGet(`/api/wallet/withdrawal-address?address=${address2}`);
+  const result = await apiGet(`/api/wallet/withdrawal-address?address=${address3}`);
   printResult(result);
 });
 
@@ -15134,12 +15370,12 @@ var revealRecoveryCodeCommand = new Command51("reveal-recovery-code").descriptio
     printError("No keystore found. Run `taskmarket init` first.");
     return;
   }
-  const address2 = keystore.walletAddress;
-  const message = buildRevealAccountRecoveryCodeMessage(address2);
-  const signature = await signMessage(message, keystore);
+  const address3 = keystore.walletAddress;
+  const message = buildRevealAccountRecoveryCodeMessage(address3);
+  const signature2 = await signMessage(message, keystore);
   const { data: result, idempotencyKey } = await apiPost("/api/wallet/reveal-backfilled-recovery-code", {
-    address: address2,
-    signature
+    address: address3,
+    signature: signature2
   });
   printResult(
     {
@@ -15207,7 +15443,7 @@ var withdrawDreamsCommand = new Command53("withdraw-dreams").description("Withdr
   const nonce = toHex2(crypto.getRandomValues(new Uint8Array(32)));
   const validBefore = String(Math.floor(Date.now() / 1e3) + AUTHORIZATION_VALIDITY_SECONDS);
   const message = buildWithdrawDreamsMessage(destination, nonce, validBefore);
-  const signature = await signMessage(message, keystore);
+  const signature2 = await signMessage(message, keystore);
   const { data: result, idempotencyKey } = await apiPost(
     "/api/wallet/withdraw-dreams",
     {
@@ -15215,7 +15451,7 @@ var withdrawDreamsCommand = new Command53("withdraw-dreams").description("Withdr
       destination,
       nonce,
       validBefore,
-      signature
+      signature: signature2
     }
   );
   printResult(
@@ -15289,7 +15525,7 @@ var withdrawCommand = new Command55("withdraw").description("Withdraw USDC to th
     validBefore: String(now + 300),
     nonce: toHex3(crypto.getRandomValues(new Uint8Array(32)))
   };
-  const signature = await signTypedData(
+  const signature2 = await signTypedData(
     {
       domain: usdcDomain,
       types: USDC_TYPES,
@@ -15304,7 +15540,7 @@ var withdrawCommand = new Command55("withdraw").description("Withdraw USDC to th
       from,
       amountBaseUnits,
       authorization,
-      signature
+      signature: signature2
     }
   );
   printResult(
@@ -15410,16 +15646,16 @@ import { Command as Command58 } from "commander";
 
 // src/lib/xmtp-client.ts
 import path10 from "path";
-import { randomUUID as randomUUID11, hkdfSync as hkdfSync2 } from "crypto";
+import { randomUUID as randomUUID12, hkdfSync as hkdfSync2 } from "crypto";
 import { privateKeyToAccount as privateKeyToAccount5 } from "viem/accounts";
 
 // src/lib/xmtp-envelope.ts
-import { randomUUID as randomUUID10 } from "crypto";
+import { randomUUID as randomUUID11 } from "crypto";
 function buildEnvelope(input2) {
   return AgentMessageEnvelopeSchema.parse({
     schemaVersion: 1,
     type: input2.type,
-    requestId: input2.requestId ?? randomUUID10(),
+    requestId: input2.requestId ?? randomUUID11(),
     replyToRequestId: input2.replyToRequestId,
     senderInboxId: input2.senderInboxId,
     senderAddress: input2.senderAddress,
@@ -15443,12 +15679,12 @@ function decodeEnvelope(raw) {
 var XmtpQueryManager = class {
   pending = /* @__PURE__ */ new Map();
   waitForResponse(requestId, timeoutMs) {
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       const timeout = setTimeout(() => {
         this.pending.delete(requestId);
         reject(new Error(`XMTP query timed out after ${timeoutMs}ms`));
       }, timeoutMs);
-      this.pending.set(requestId, { resolve, reject, timeout });
+      this.pending.set(requestId, { resolve: resolve2, reject, timeout });
     });
   }
   resolveResponse(envelope) {
@@ -15512,13 +15748,13 @@ function shouldHandleEnvelope(envelope, options) {
   return true;
 }
 function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
 async function runStreamWithReconnect(options) {
   const maxReconnectAttempts = options.maxReconnectAttempts ?? Number.POSITIVE_INFINITY;
   const backoffMs = options.backoffMs ?? ((attempt) => {
-    const base2 = Math.min(3e4, 250 * 2 ** attempt);
-    return base2 * (0.5 + Math.random() * 0.5);
+    const base3 = Math.min(3e4, 250 * 2 ** attempt);
+    return base3 * (0.5 + Math.random() * 0.5);
   });
   let reconnectAttempt = 0;
   while (!options.shouldStop()) {
@@ -15572,7 +15808,7 @@ function defaultDbPath(walletAddress2) {
 }
 async function createDevClient(input2) {
   const inboxId = input2.existingInboxId ?? `dev-inbox-${input2.walletAddress.slice(2, 10).toLowerCase()}`;
-  const installationId = input2.existingInstallationId ?? randomUUID11();
+  const installationId = input2.existingInstallationId ?? randomUUID12();
   const dbPath = input2.existingDbPath ?? defaultDbPath(input2.walletAddress);
   return {
     inboxId,
@@ -15594,7 +15830,7 @@ async function createDevClient(input2) {
           }
           continue;
         }
-        await new Promise((resolve) => setTimeout(resolve, 250));
+        await new Promise((resolve2) => setTimeout(resolve2, 250));
       }
     },
     async setConsentState(_inboxId, _state) {
@@ -15688,7 +15924,7 @@ function toTransportError(error, fallbackMessage) {
   return new XmtpTransportError(message, category, error);
 }
 function sleep2(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
 function parseRetryAttempts() {
   const raw = process.env.TASKMARKET_XMTP_SEND_MAX_ATTEMPTS;
@@ -15702,9 +15938,9 @@ function parseRetryAttempts() {
   return Math.floor(parsed);
 }
 function sendBackoffMs(attempt) {
-  const base2 = DEFAULT_SEND_RETRY_BASE_DELAY_MS * 2 ** Math.max(attempt - 1, 0);
+  const base3 = DEFAULT_SEND_RETRY_BASE_DELAY_MS * 2 ** Math.max(attempt - 1, 0);
   const jitter = Math.floor(Math.random() * DEFAULT_SEND_RETRY_BASE_DELAY_MS);
-  return Math.min(DEFAULT_SEND_RETRY_MAX_DELAY_MS, base2 + jitter);
+  return Math.min(DEFAULT_SEND_RETRY_MAX_DELAY_MS, base3 + jitter);
 }
 async function withRetry(operation, maxAttempts) {
   for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
@@ -16001,7 +16237,7 @@ async function createProductionClient(input2) {
       "non-retryable"
     );
   }
-  const installationId = extractString(client, ["installationId", "installationID"]) ?? extractString(asObject(client)?.installation, ["id", "installationId"]) ?? input2.existingInstallationId ?? randomUUID11();
+  const installationId = extractString(client, ["installationId", "installationID"]) ?? extractString(asObject(client)?.installation, ["id", "installationId"]) ?? input2.existingInstallationId ?? randomUUID12();
   return {
     inboxId,
     installationId,
@@ -16421,13 +16657,13 @@ function collectNewTaskIds(tasks, seenIds) {
   return tasks.filter((t) => !seenIds.has(t.id)).map((t) => t.id);
 }
 function sleepOrAbort(ms, signal) {
-  return new Promise((resolve) => {
-    const id3 = setTimeout(resolve, ms);
+  return new Promise((resolve2) => {
+    const id3 = setTimeout(resolve2, ms);
     signal.addEventListener(
       "abort",
       () => {
         clearTimeout(id3);
-        resolve();
+        resolve2();
       },
       { once: true }
     );
@@ -16473,7 +16709,7 @@ var daemonCommand = new Command59("daemon").description("Long-running agent daem
       }
     }
     const keystore = await loadKeystore();
-    const address2 = keystore.walletAddress;
+    const address3 = keystore.walletAddress;
     let stopped = false;
     const abortController = new AbortController();
     const stop = () => {
@@ -16555,7 +16791,7 @@ var daemonCommand = new Command59("daemon").description("Long-running agent daem
         };
         try {
           const inbox = await apiGet(
-            `/api/agents/inbox?address=${encodeURIComponent(address2)}`
+            `/api/agents/inbox?address=${encodeURIComponent(address3)}`
           );
           for (const task of [...inbox.asRequester, ...inbox.asWorker]) {
             knownStatuses.set(task.id, task.status);
@@ -16575,7 +16811,7 @@ var daemonCommand = new Command59("daemon").description("Long-running agent daem
             if (stopped) break;
             try {
               const inbox = await apiGet(
-                `/api/agents/inbox?address=${encodeURIComponent(address2)}`
+                `/api/agents/inbox?address=${encodeURIComponent(address3)}`
               );
               const allTasks = [...inbox.asRequester, ...inbox.asWorker];
               const nextStatuses = /* @__PURE__ */ new Map();
@@ -16915,12 +17151,12 @@ import { Command as Command70 } from "commander";
 
 // src/commands/requester/stats.ts
 import { Command as Command69 } from "commander";
-var requesterStatsCmd = new Command69("stats").description("Get requester reputation stats for an address").argument("<address>", "Wallet address of the requester").action(async (address2) => {
-  if (!/^0x[0-9a-fA-F]{40}$/.test(address2)) {
+var requesterStatsCmd = new Command69("stats").description("Get requester reputation stats for an address").argument("<address>", "Wallet address of the requester").action(async (address3) => {
+  if (!/^0x[0-9a-fA-F]{40}$/.test(address3)) {
     printError("Address must be a 0x-prefixed 20-byte hex string");
     return;
   }
-  const data = await apiGet(`/api/requester/${address2}/stats`);
+  const data = await apiGet(`/api/requester/${address3}/stats`);
   if (!data) {
     printError("No stats found for address");
     return;
@@ -16953,9 +17189,9 @@ async function confirmManualResolution() {
   if (!process.stdin.isTTY) throw new Error("Manual resolution requires an interactive TTY");
   const readline = createInterface3({ input: process.stdin, output: process.stderr });
   const answer = await new Promise(
-    (resolve) => readline.question(
+    (resolve2) => readline.question(
       "Manual resolution changes local spending accounting. Type resolve to continue: ",
-      resolve
+      resolve2
     )
   );
   readline.close();
@@ -17011,7 +17247,7 @@ async function confirmUnattendedRule(rule) {
   );
   const readline = createInterface4({ input: process.stdin, output: process.stderr });
   const answer = await new Promise(
-    (resolve) => readline.question("Type authorize to grant unattended spending: ", resolve)
+    (resolve2) => readline.question("Type authorize to grant unattended spending: ", resolve2)
   );
   readline.close();
   return answer.trim().toLowerCase() === "authorize";
@@ -17065,7 +17301,7 @@ async function confirm(lines) {
 `);
   const readline = createInterface5({ input: process.stdin, output: process.stderr });
   const answer = await new Promise(
-    (resolve) => readline.question("Type yes to approve: ", resolve)
+    (resolve2) => readline.question("Type yes to approve: ", resolve2)
   );
   readline.close();
   return answer.trim().toLowerCase() === "yes";
@@ -17126,7 +17362,7 @@ x402Command.addCommand(x402PolicyCommand);
 x402Command.addCommand(x402PaymentsCommand);
 
 // src/commands/sponsored-task/index.ts
-import { Command as Command85 } from "commander";
+import { Command as Command89 } from "commander";
 
 // src/commands/sponsored-task/create.ts
 import { Command as Command75 } from "commander";
@@ -20248,10 +20484,10 @@ var SponsoredTaskFeeBankABI = [
 
 // src/lib/sponsored-task-chain.ts
 import {
-  createPublicClient as createPublicClient3,
+  createPublicClient as createPublicClient4,
   createWalletClient as createWalletClient2,
   defineChain as defineChain3,
-  http as http4
+  http as http5
 } from "viem";
 function resolveRpcUrl() {
   const value = process.env["TASKMARKET_RPC_URL"]?.trim();
@@ -20270,13 +20506,13 @@ async function createSponsoredTaskVaultChainClients(keystore, chainId) {
     nativeCurrency: { name: "Native gas token", symbol: "GAS", decimals: 18 },
     rpcUrls: { default: { http: [rpcUrl] } }
   });
-  const publicClient = createPublicClient3({ chain, transport: http4(rpcUrl) });
+  const publicClient = createPublicClient4({ chain, transport: http5(rpcUrl) });
   const rpcChainId = await publicClient.getChainId();
   if (rpcChainId !== chainId) {
     throw new Error(`TASKMARKET_RPC_URL points at chain ${rpcChainId}, vault needs ${chainId}`);
   }
   const account = await createWalletAccountFromKeystore(keystore);
-  const walletClient = createWalletClient2({ account, chain, transport: http4(rpcUrl) });
+  const walletClient = createWalletClient2({ account, chain, transport: http5(rpcUrl) });
   return { account, chain, publicClient, walletClient };
 }
 async function writeSponsoredTaskVaultContract(input2) {
@@ -20343,7 +20579,7 @@ async function approveSponsoredTaskSpend(input2) {
         `Approval confirmed but TASKMARKET_RPC_URL still reports an allowance of ${allowance}; retry once the endpoint catches up`
       );
     }
-    await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+    await new Promise((resolve2) => setTimeout(resolve2, pollIntervalMs));
   }
 }
 
@@ -20487,8 +20723,39 @@ sponsoredTaskManagersCommand.command("list").description("List a vault authorize
   printResult(managers);
 });
 
-// src/commands/sponsored-task/fee-bank.ts
+// src/commands/sponsored-task/managed.ts
 import { Command as Command78 } from "commander";
+var sponsoredTaskManagedCommand = new Command78("managed").description(
+  "List the active Sponsored Task vaults an address can fund tasks from as an active manager (defaults to your wallet)"
+).option("--address <address>", "Manager address (defaults to your wallet)").option("--limit <n>", "Max vaults to return (1-100)", "50").option("--cursor <vaultId>", "Pagination cursor from a previous nextCursor").action(async (opts) => {
+  let address3 = opts.address;
+  if (address3 === void 0) {
+    try {
+      address3 = (await loadKeystore()).walletAddress;
+    } catch {
+      printError("No keystore found. Run `taskmarket init` first, or pass --address.");
+      return;
+    }
+  }
+  if (!/^0x[a-fA-F0-9]{40}$/.test(address3)) {
+    printError("Invalid Ethereum address for --address");
+    return;
+  }
+  const limit = Number(opts.limit);
+  if (!Number.isInteger(limit) || limit < 1 || limit > 100) {
+    printError("--limit must be an integer from 1 to 100");
+    return;
+  }
+  const params = new URLSearchParams({ limit: String(limit) });
+  if (opts.cursor) params.set("cursor", opts.cursor);
+  const result = await apiGet(
+    `/api/sponsored-task-vaults/managed/${address3.toLowerCase()}?${params.toString()}`
+  );
+  printResult(result);
+});
+
+// src/commands/sponsored-task/fee-bank.ts
+import { Command as Command79 } from "commander";
 function isValidAddress7(addr) {
   return /^0x[a-fA-F0-9]{40}$/.test(addr);
 }
@@ -20500,7 +20767,7 @@ async function requireKeystore2() {
     return null;
   }
 }
-var sponsoredTaskFeeBankCommand = new Command78("fee-bank").description(
+var sponsoredTaskFeeBankCommand = new Command79("fee-bank").description(
   "Manage a manager USDC credit balance, charged by the Sponsored Task hook at task creation"
 );
 sponsoredTaskFeeBankCommand.command("deposit").description("Deposit USDC credit for creating sponsored tasks").requiredOption("--fee-bank <address>", "SponsoredTaskFeeBank contract address").requiredOption("--usdc <address>", "USDC token address").requiredOption("--chain-id <id>", "Chain id the fee bank is deployed on").requiredOption("--amount <baseUnits>", "Amount to deposit, in USDC base units (6 decimals)").action(async (opts) => {
@@ -20584,8 +20851,8 @@ sponsoredTaskFeeBankCommand.command("withdraw").description("Withdraw unused USD
 );
 
 // src/commands/sponsored-task/list.ts
-import { Command as Command79 } from "commander";
-var sponsoredTaskListCommand = new Command79("list").description("List Sponsored Task vaults").option("--limit <n>", "Max vaults to return", "50").option("--cursor <vaultId>", "Pagination cursor").option("--include-unverified", "Include vaults not yet curator-approved", false).action(async (opts) => {
+import { Command as Command80 } from "commander";
+var sponsoredTaskListCommand = new Command80("list").description("List Sponsored Task vaults").option("--limit <n>", "Max vaults to return", "50").option("--cursor <vaultId>", "Pagination cursor").option("--include-unverified", "Include vaults not yet curator-approved", false).action(async (opts) => {
   const params = new URLSearchParams({ limit: opts.limit });
   if (opts.cursor) params.set("cursor", opts.cursor);
   if (opts.includeUnverified) params.set("includeUnverified", "true");
@@ -20593,26 +20860,102 @@ var sponsoredTaskListCommand = new Command79("list").description("List Sponsored
   printResult(result);
 });
 
+// src/commands/sponsored-task/settlements.ts
+import { Command as Command81 } from "commander";
+var sponsoredTaskSettlementsCommand = new Command81("settlements").description("List the settlements a Sponsored Task vault has installed, newest first").argument("<vaultId>", "Vault id").option("--limit <n>", "Max settlements to return (1-100)", "25").option("--cursor <cursor>", "Pagination cursor from a previous nextCursor").action(async (vaultId, opts) => {
+  const limit = Number(opts.limit);
+  if (!Number.isInteger(limit) || limit < 1 || limit > 100) {
+    printError("--limit must be an integer from 1 to 100");
+    return;
+  }
+  const params = new URLSearchParams({ limit: String(limit) });
+  if (opts.cursor) params.set("cursor", opts.cursor);
+  const result = await apiGet(
+    `/api/sponsored-task-vaults/${vaultId}/settlements?${params.toString()}`
+  );
+  printResult(result);
+});
+
 // src/commands/sponsored-task/show.ts
-import { Command as Command80 } from "commander";
-var sponsoredTaskShowCommand = new Command80("show").description("Show a Sponsored Task vault by id").argument("<vaultId>", "Vault id").action(async (vaultId) => {
+import { Command as Command82 } from "commander";
+var sponsoredTaskShowCommand = new Command82("show").description("Show a Sponsored Task vault by id").argument("<vaultId>", "Vault id").action(async (vaultId) => {
   const result = await apiGet(`/api/sponsored-task-vaults/${vaultId}`);
   printResult(result);
 });
 
+// src/commands/sponsored-task/request-review.ts
+import { randomBytes as randomBytes4 } from "crypto";
+import { Command as Command83 } from "commander";
+var REQUEST_TTL_SECONDS = 5 * 60;
+var sponsoredTaskRequestReviewCommand = new Command83("request-review").description("Ask Taskmarket curators to review a Sponsored Task vault (vault owner only)").argument("<vaultId>", "Vault id").action(async (vaultId) => {
+  let keystore;
+  try {
+    keystore = await loadKeystore();
+  } catch {
+    printError("No keystore found. Run `taskmarket init` first.");
+    return;
+  }
+  const owner = keystore.walletAddress;
+  const vault = await apiGet(`/api/sponsored-task-vaults/${vaultId}`);
+  if (vault.curationStatus === "approved") {
+    printError("Vault is already approved");
+    return;
+  }
+  if (vault.owner.toLowerCase() !== owner.toLowerCase()) {
+    printError(
+      `Only the vault owner (${vault.owner}) can request a review; your wallet is ${owner}`
+    );
+    return;
+  }
+  const nonce = `0x${randomBytes4(32).toString("hex")}`;
+  const expiresAt = Math.floor(Date.now() / 1e3) + REQUEST_TTL_SECONDS;
+  const signature2 = await signMessage(
+    buildSponsoredTaskVaultReviewRequestMessage({
+      vaultId: vault.vaultId,
+      chainId: vault.chainId,
+      owner,
+      nonce,
+      expiresAt
+    }),
+    keystore
+  );
+  let data;
+  try {
+    ({ data } = await apiPost(
+      `/api/sponsored-task-vaults/${vault.vaultId}/review-request`,
+      { ownerAddress: owner, nonce, expiresAt, signature: signature2 }
+    ));
+  } catch (err) {
+    if (err instanceof ApiError && err.status === 429) {
+      renderFailure(err, {
+        details: {
+          hint: "A new review request is accepted 24 hours after the last one was made or decided."
+        }
+      });
+      return;
+    }
+    throw err;
+  }
+  printResult({
+    vaultId: data.vaultId,
+    reviewRequestedAt: data.reviewRequestedAt,
+    alreadyOpen: vault.reviewRequestedAt !== null
+  });
+});
+
 // src/commands/sponsored-task/balance.ts
-import { Command as Command81 } from "commander";
-var sponsoredTaskBalanceCommand = new Command81("balance").description("Show a Sponsored Task vault funded/available/reserved balances").argument("<vaultId>", "Vault id").action(async (vaultId) => {
+import { Command as Command84 } from "commander";
+var sponsoredTaskBalanceCommand = new Command84("balance").description("Show a Sponsored Task vault funded/available/reserved balances").argument("<vaultId>", "Vault id").action(async (vaultId) => {
   const result = await apiGet(`/api/sponsored-task-vaults/${vaultId}/balance`);
   printResult(result);
 });
 
 // src/commands/sponsored-task/withdraw.ts
-import { Command as Command82 } from "commander";
+import { Command as Command85 } from "commander";
 function isValidAddress8(addr) {
   return /^0x[a-fA-F0-9]{40}$/.test(addr);
 }
-var sponsoredTaskWithdrawCommand = new Command82("withdraw").description("Withdraw unreserved project tokens from a vault (owner only)").requiredOption("--vault <address>", "Vault address").requiredOption("--chain-id <id>", "Chain id the vault is deployed on").requiredOption("--amount <baseUnits>", "Amount to withdraw, in the project token base units").option("--recipient <address>", "Recipient (defaults to your own wallet)").action(async (opts) => {
+var sponsoredTaskWithdrawCommand = new Command85("withdraw").description("Withdraw unreserved project tokens from a vault (owner only)").requiredOption("--vault <address>", "Vault address").requiredOption("--chain-id <id>", "Chain id the vault is deployed on").requiredOption("--amount <baseUnits>", "Amount to withdraw, in the project token base units").option("--recipient <address>", "Recipient (defaults to your own wallet)").action(async (opts) => {
   if (!isValidAddress8(opts.vault) || opts.recipient && !isValidAddress8(opts.recipient)) {
     printError("Invalid Ethereum address for --vault or --recipient");
     return;
@@ -20642,11 +20985,11 @@ var sponsoredTaskWithdrawCommand = new Command82("withdraw").description("Withdr
 });
 
 // src/commands/sponsored-task/exit.ts
-import { Command as Command83 } from "commander";
+import { Command as Command86 } from "commander";
 function isValidAddress9(addr) {
   return /^0x[a-fA-F0-9]{40}$/.test(addr);
 }
-var sponsoredTaskExitCommand = new Command83("exit").description(
+var sponsoredTaskExitCommand = new Command86("exit").description(
   "Terminally exit a vault: sweeps every reserved and unclaimed token back to you, invalidating every outstanding reservation, claim signature, and Merkle proof at once. There is no undo and no per-allocation revoke -- a worker with a pending but unclaimed entitlement gets nothing once this runs."
 ).requiredOption("--vault <address>", "Vault address").requiredOption("--chain-id <id>", "Chain id the vault is deployed on").option("--recipient <address>", "Recipient (defaults to your own wallet)").option("--yes", "Skip the confirmation prompt", false).action(async (opts) => {
   if (!isValidAddress9(opts.vault) || opts.recipient && !isValidAddress9(opts.recipient)) {
@@ -20682,7 +21025,7 @@ var sponsoredTaskExitCommand = new Command83("exit").description(
 });
 
 // src/commands/sponsored-task/claim.ts
-import { Command as Command84 } from "commander";
+import { Command as Command87 } from "commander";
 var CLAIM_TO_TYPES = {
   ClaimTo: [
     { name: "vaultId", type: "bytes32" },
@@ -20717,7 +21060,7 @@ async function postClaimWithRetry(path11, body, options = {}) {
     }
   }
 }
-var sponsoredTaskClaimCommand = new Command84("claim").description("Claim your unclaimed Sponsored Task reward for a vault task").argument("<vaultId>", "Vault id").option(
+var sponsoredTaskClaimCommand = new Command87("claim").description("Claim your unclaimed Sponsored Task reward for a vault task").argument("<vaultId>", "Vault id").option(
   "--task-id <id>",
   "Claim the entitlement for a specific task (defaults to the first unclaimed one)"
 ).action(async (vaultId, opts) => {
@@ -20764,7 +21107,7 @@ var sponsoredTaskClaimCommand = new Command84("claim").description("Claim your u
     nonce,
     deadline
   };
-  const signature = await signTypedData(
+  const signature2 = await signTypedData(
     {
       domain: {
         name: "SponsoredTasksVault",
@@ -20789,32 +21132,79 @@ var sponsoredTaskClaimCommand = new Command84("claim").description("Claim your u
       amount: entitlement.amount,
       nonce,
       deadline,
-      signature,
+      signature: signature2,
       proof: entitlement.proof
     }
   );
   printResult(result, { idempotencyKey });
 });
 
+// src/commands/sponsored-task/rewards.ts
+import { Command as Command88 } from "commander";
+var REWARD_STATES = SponsoredTaskRewardStateSchema.options;
+var CLAIM_STATUSES = SponsoredTaskWorkerRewardClaimStatusSchema.options;
+var sponsoredTaskRewardsCommand = new Command88("rewards").description("List Sponsored Task rewards across every vault (defaults to your wallet)").option("--address <address>", "Worker address (defaults to your wallet)").option("--state <state>", `Reward state: ${REWARD_STATES.join(", ")}`).option("--claim-status <status>", `Claim status: ${CLAIM_STATUSES.join(", ")}`).option("--limit <n>", "Max rewards to return (1-100)", "50").option("--cursor <cursor>", "Pagination cursor from a previous nextCursor").action(
+  async (opts) => {
+    let address3 = opts.address;
+    if (address3 === void 0) {
+      try {
+        address3 = (await loadKeystore()).walletAddress;
+      } catch {
+        printError("No keystore found. Run `taskmarket init` first, or pass --address.");
+        return;
+      }
+    }
+    if (!/^0x[a-fA-F0-9]{40}$/.test(address3)) {
+      printError("Invalid Ethereum address for --address");
+      return;
+    }
+    if (opts.state && !REWARD_STATES.includes(opts.state)) {
+      printError(`Invalid --state. Use one of: ${REWARD_STATES.join(", ")}`);
+      return;
+    }
+    if (opts.claimStatus && !CLAIM_STATUSES.includes(opts.claimStatus)) {
+      printError(`Invalid --claim-status. Use one of: ${CLAIM_STATUSES.join(", ")}`);
+      return;
+    }
+    const limit = Number(opts.limit);
+    if (!Number.isInteger(limit) || limit < 1 || limit > 100) {
+      printError("--limit must be an integer from 1 to 100");
+      return;
+    }
+    const params = new URLSearchParams({ limit: String(limit) });
+    if (opts.state) params.set("state", opts.state);
+    if (opts.claimStatus) params.set("claimStatus", opts.claimStatus);
+    if (opts.cursor) params.set("cursor", opts.cursor);
+    const result = await apiGet(
+      `/api/sponsored-task-rewards/workers/${address3.toLowerCase()}?${params.toString()}`
+    );
+    printResult(result);
+  }
+);
+
 // src/commands/sponsored-task/index.ts
-var sponsoredTaskCommand = new Command85("sponsored-task").description(
+var sponsoredTaskCommand = new Command89("sponsored-task").description(
   "Sponsored Task vault administration and reward claims"
 );
 sponsoredTaskCommand.addCommand(sponsoredTaskCreateCommand);
 sponsoredTaskCommand.addCommand(sponsoredTaskFundCommand);
 sponsoredTaskCommand.addCommand(sponsoredTaskManagersCommand);
+sponsoredTaskCommand.addCommand(sponsoredTaskManagedCommand);
 sponsoredTaskCommand.addCommand(sponsoredTaskFeeBankCommand);
 sponsoredTaskCommand.addCommand(sponsoredTaskListCommand);
+sponsoredTaskCommand.addCommand(sponsoredTaskSettlementsCommand);
 sponsoredTaskCommand.addCommand(sponsoredTaskShowCommand);
+sponsoredTaskCommand.addCommand(sponsoredTaskRequestReviewCommand);
 sponsoredTaskCommand.addCommand(sponsoredTaskBalanceCommand);
 sponsoredTaskCommand.addCommand(sponsoredTaskWithdrawCommand);
 sponsoredTaskCommand.addCommand(sponsoredTaskExitCommand);
 sponsoredTaskCommand.addCommand(sponsoredTaskClaimCommand);
+sponsoredTaskCommand.addCommand(sponsoredTaskRewardsCommand);
 
 // src/index.ts
 var require2 = createRequire(import.meta.url);
 var { version } = require2("../package.json");
-var program = new Command86();
+var program = new Command90();
 program.name("taskmarket").description("Taskmarket CLI for AI agents").version(version);
 program.addCommand(initCommand);
 program.addCommand(walletCommand);