@lucid-agents/taskmarket 0.9.0 → 1.1.0

package/dist/index.js

@@ -6,7 +6,7 @@ var __export = (target, all) => {
 };
 
 // src/index.ts
-import { Command as Command42 } from "commander";
+import { Command as Command52 } from "commander";
 import { createRequire } from "module";
 
 // src/commands/init.ts
@@ -73,7 +73,7 @@ async function keystoreExists(keystorePath) {
 }
 
 // src/lib/api.ts
-var API_URL = process.env.TASKMARKET_API_URL ?? "https://api-market.daydreams.systems";
+var API_URL = process.env.TASKMARKET_API_URL ?? "https://api.taskmarket.dev";
 async function apiGet(path3, options) {
   const res = await fetch(`${API_URL}${path3}`, {
     method: "GET",
@@ -198,6 +198,14 @@ function decryptWithPrivateKey(fileBuffer, privateKeyHex) {
 }
 
 // src/commands/init.ts
+function sanitizeEmailUsername(agentId, suffix) {
+  const maxBase = 30 - 1 - suffix.length;
+  if (maxBase < 2) return null;
+  const base = agentId.toLowerCase().replace(/[^a-z0-9]/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "").slice(0, maxBase).replace(/-+$/, "");
+  if (base.length < 2) return null;
+  const candidate = `${base}-${suffix}`;
+  return /^[a-z0-9][a-z0-9-]{1,28}[a-z0-9]$/.test(candidate) ? candidate : null;
+}
 async function tryRegisterEmail(deviceId, apiToken, username, explicit) {
   try {
     const reg = await apiPost("/api/emails/register", {
@@ -253,7 +261,7 @@ var initCommand = new Command("init").description("Create and register a new age
     } catch {
     }
     if (!emailAddress2) {
-      const username2 = opts.email ?? (agentId2 && networkInfo2 ? `${agentId2}-${networkInfo2.chainId}` : null);
+      const username2 = opts.email ?? (agentId2 && networkInfo2 ? sanitizeEmailUsername(agentId2, String(networkInfo2.chainId)) : null);
       if (username2) {
         emailAddress2 = await tryRegisterEmail(
           keystore.deviceId,
@@ -291,7 +299,14 @@ var initCommand = new Command("init").description("Create and register a new age
   } = await res.json();
   const encryptedKey = encryptPrivateKey(deviceEncryptionKey, privateKey);
   let agentId = initialAgentId;
-  await saveKeystore({ encryptedKey, walletAddress: address, deviceId, apiToken, agentId });
+  await saveKeystore({
+    encryptedKey,
+    walletAddress: address,
+    deviceId,
+    apiToken,
+    agentId,
+    keyServerUrl: API_URL
+  });
   if (!agentId) {
     agentId = await pollAgentId(address);
     if (agentId) {
@@ -305,7 +320,7 @@ var initCommand = new Command("init").description("Create and register a new age
     networkInfo = response.result.data;
   } catch {
   }
-  const username = opts.email ?? (agentId && networkInfo ? `${agentId}-${networkInfo.chainId}` : null);
+  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,
@@ -329,8 +344,9 @@ import { Command as Command3 } from "commander";
 // src/lib/signer.ts
 import { privateKeyToAccount as privateKeyToAccount2 } from "viem/accounts";
 import { toHex } from "viem";
-async function fetchDeviceKey(deviceId, apiToken) {
-  const res = await fetch(`${API_URL}/api/devices/${deviceId}/key`, {
+async function fetchDeviceKey(deviceId, apiToken, keyServerUrl) {
+  const base = keyServerUrl ?? API_URL;
+  const res = await fetch(`${base}/api/devices/${deviceId}/key`, {
     method: "POST",
     headers: { "Content-Type": "application/json" },
     body: JSON.stringify({ deviceId, apiToken })
@@ -353,7 +369,7 @@ async function signMessage(message, keystore) {
   return sig;
 }
 async function createWalletAccountFromKeystore(keystore) {
-  const dek = await fetchDeviceKey(keystore.deviceId, keystore.apiToken);
+  const dek = await fetchDeviceKey(keystore.deviceId, keystore.apiToken, keystore.keyServerUrl);
   const privateKey = decryptPrivateKey(dek, keystore.encryptedKey);
   return privateKeyToAccount2(privateKey);
 }
@@ -467,6 +483,7 @@ var statsCommand = new Command4("stats").description("View agent statistics").op
     completedTasks: result.completedTasks,
     ratedTasks: result.ratedTasks,
     averageRating: result.averageRating,
+    credibility: result.credibility,
     totalEarnings: result.totalEarnings,
     skills: result.skills,
     emailAddress: result.emailAddress,
@@ -475,14 +492,44 @@ var statsCommand = new Command4("stats").description("View agent statistics").op
 });
 
 // src/commands/task/index.ts
-import { Command as Command19 } from "commander";
+import { Command as Command29 } from "commander";
 
 // src/commands/task/create.ts
 import { Command as Command5 } from "commander";
-var createCmd = new Command5("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("--tags <tags>", "Comma-separated tags").option("--pitch-deadline <hours>", "Pitch deadline in hours from now (pitch mode only)").option("--bid-deadline <hours>", "Bid deadline in hours from now (auction mode only)").option("--max-price <usdc>", "Maximum bid price in USDC (required for auction mode)").action(
+var createCmd = new Command5("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("--tags <tags>", "Comma-separated tags").option("--pitch-deadline <hours>", "Pitch deadline in hours from now (pitch mode only)").option("--bid-deadline <hours>", "Bid deadline in hours from now (auction mode only)").option("--max-price <usdc>", "Maximum bid price in USDC (required for auction mode)").option(
+  "--auction-type <type>",
+  "Auction subtype: dutch, english, reverse_dutch, reverse_english (required for auction mode)"
+).option(
+  "--auction-start-price <usdc>",
+  "Starting clock price in USDC for reverse_dutch (required for reverse_dutch)"
+).option(
+  "--auction-floor-price <usdc>",
+  "Floor price in USDC for dutch clock (optional, defaults to 0)"
+).option("--hook <address>", "ITaskHook contract address (optional)").option(
+  "--hook-data <hex>",
+  "Hook config bytes forwarded to checkFund; encode uint32 as 4 big-endian bytes (e.g. 0x000006b4 for a 1800s TWAP window)"
+).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) => {
-    if (opts.mode === "auction" && !opts.maxPrice) {
-      printError("--max-price is required for auction mode");
+    if (opts.mode === "auction") {
+      if (!opts.maxPrice) {
+        return void printError("--max-price is required for auction mode");
+      }
+      if (!opts.auctionType) {
+        return void printError(
+          "--auction-type is required for auction mode (dutch, english, reverse_dutch, reverse_english)"
+        );
+      }
+      const validTypes = ["dutch", "english", "reverse_dutch", "reverse_english"];
+      if (!validTypes.includes(opts.auctionType)) {
+        return void printError(
+          `--auction-type must be one of: ${validTypes.join(", ")}. Got: ${opts.auctionType}`
+        );
+      }
+      if (opts.auctionType === "reverse_dutch" && !opts.auctionStartPrice) {
+        return void printError(
+          "--auction-start-price is required for reverse_dutch auction type"
+        );
+      }
     }
     const rewardBaseUnits = String(Math.round(parseFloat(opts.reward) * 1e6));
     const tags = opts.tags ? opts.tags.split(",").map((t) => t.trim()) : [];
@@ -504,6 +551,52 @@ var createCmd = new Command5("create").description("Create a new task (costs rew
     if (opts.maxPrice) {
       body.maxPrice = String(Math.round(parseFloat(opts.maxPrice) * 1e6));
     }
+    if (opts.auctionType) {
+      body.auctionType = opts.auctionType;
+    }
+    if (opts.auctionStartPrice) {
+      body.auctionStartPrice = String(Math.round(parseFloat(opts.auctionStartPrice) * 1e6));
+    }
+    if (opts.auctionFloorPrice) {
+      body.auctionFloorPrice = String(Math.round(parseFloat(opts.auctionFloorPrice) * 1e6));
+    }
+    const ethAddrRe = /^0x[0-9a-fA-F]{40}$/;
+    if (opts.hook && !ethAddrRe.test(opts.hook)) {
+      return void printError("--hook must be a valid Ethereum address (0x + 40 hex chars)");
+    }
+    if (opts.hookData && !/^0x(?:[0-9a-fA-F]{2})*$/.test(opts.hookData)) {
+      return void printError(
+        "--hook-data must be a 0x-prefixed hex string with an even number of hex digits"
+      );
+    }
+    let feeBps;
+    if (opts.evaluator) {
+      if (!ethAddrRe.test(opts.evaluator)) {
+        return void printError(
+          "--evaluator must be a valid Ethereum address (0x + 40 hex chars)"
+        );
+      }
+      if (opts.evaluatorFeeBps) {
+        feeBps = Number(opts.evaluatorFeeBps);
+        if (!Number.isInteger(feeBps) || feeBps < 0 || feeBps > 1e4) {
+          return void printError("--evaluator-fee-bps must be an integer between 0 and 10000");
+        }
+      }
+      if (opts.disputeResolver && !ethAddrRe.test(opts.disputeResolver)) {
+        return void printError(
+          "--dispute-resolver must be a valid Ethereum address (0x + 40 hex chars)"
+        );
+      }
+    }
+    if (opts.hook) body.hookContract = opts.hook;
+    if (opts.hookData) body.hookData = opts.hookData;
+    if (opts.evaluator) {
+      body.evaluator = opts.evaluator;
+      if (feeBps !== void 0) body.evaluatorFeeBps = feeBps;
+      if (opts.evaluationWindow) body.evaluationWindowHours = parseFloat(opts.evaluationWindow);
+      if (opts.appealWindow) body.appealWindowHours = parseFloat(opts.appealWindow);
+      if (opts.disputeResolver) body.disputeResolver = opts.disputeResolver;
+    }
     const result = await x402Post("/api/tasks", body);
     printResult({ taskId: result.taskId });
   }
@@ -511,11 +604,15 @@ var createCmd = new Command5("create").description("Create a new task (costs rew
 
 // src/commands/task/search.ts
 import { Command as Command6 } from "commander";
-var listCmd = new Command6("list").alias("search").description("List available tasks").option("--status <status>", "Filter by status (e.g. open)", "open").option("--mode <mode>", "Filter by mode (bounty, claim, pitch, benchmark, auction)").option("--tags <tags>", "Comma-separated tags to filter by").option("--skill <skill>", "Filter by skill tag (comma-separated, alias for --tags)").option("--reward-min <n>", "Minimum reward in USDC").option("--reward-max <n>", "Maximum reward in USDC").option("--deadline-hours <n>", "Only tasks expiring within this many hours").option("--limit <n>", "Maximum results to return", "20").option("--cursor <cursor>", "Cursor from previous page (nextCursor in JSON output)").action(
+var listCmd = new Command6("list").alias("search").description("List available tasks").option("--status <status>", "Filter by status (e.g. open)", "open").option("--mode <mode>", "Filter by mode (bounty, claim, pitch, benchmark, auction)").option(
+  "--auction-type <type>",
+  "Filter auction tasks by subtype (dutch, english, reverse_dutch, reverse_english)"
+).option("--tags <tags>", "Comma-separated tags to filter by").option("--skill <skill>", "Filter by skill tag (comma-separated, alias for --tags)").option("--reward-min <n>", "Minimum reward in USDC").option("--reward-max <n>", "Maximum reward in USDC").option("--deadline-hours <n>", "Only tasks expiring within this many hours").option("--limit <n>", "Maximum results to return", "20").option("--cursor <cursor>", "Cursor from previous page (nextCursor in JSON output)").action(
   async (opts) => {
     const params = new URLSearchParams();
     if (opts.status) params.set("status", opts.status);
     if (opts.mode) params.set("mode", opts.mode);
+    if (opts.auctionType) params.set("auctionType", opts.auctionType);
     const tagsValue = opts.tags ?? opts.skill;
     if (tagsValue) params.set("tags", tagsValue);
     if (opts.rewardMin)
@@ -541,50 +638,245 @@ var getCmd = new Command7("get").description("Get task details").argument("<task
 });
 
 // src/commands/task/submit.ts
-import { Command as Command8 } from "commander";
-import { promises as fs2 } from "fs";
-var submitCmd = new Command8("submit").description("Submit work for a task").argument("<taskId>", "Task ID (0x-prefixed hex)").requiredOption("--file <path>", "Path to the submission file").action(async (taskId, opts) => {
-  const fileContent = await fs2.readFile(opts.file);
-  const fileBase64 = fileContent.toString("base64");
-  const keystore = await loadKeystore();
-  const signature = await signMessage(`taskmarket:submit:${taskId}`, keystore);
-  const result = await apiPost(`/api/tasks/${taskId}/submissions`, {
-    workerAddress: keystore.walletAddress,
-    file: fileBase64,
-    signature
+import { Command as Command8, Option } from "commander";
+import { promises as fsPromises } from "fs";
+import { basename, extname } from "path";
+import { createHash } from "crypto";
+import { Readable } from "stream";
+import https from "https";
+import http from "http";
+import { keccak256 } from "viem";
+function collectFile(value, previous) {
+  return [...previous, value];
+}
+function mimeTypeForPath(filePath) {
+  switch (extname(filePath).toLowerCase()) {
+    case ".png":
+      return "image/png";
+    case ".jpg":
+    case ".jpeg":
+      return "image/jpeg";
+    case ".webp":
+      return "image/webp";
+    case ".gif":
+      return "image/gif";
+    case ".svg":
+      return "image/svg+xml";
+    case ".pdf":
+      return "application/pdf";
+    case ".mp4":
+      return "video/mp4";
+    case ".webm":
+      return "video/webm";
+    case ".mp3":
+      return "audio/mpeg";
+    case ".wav":
+      return "audio/wav";
+    case ".md":
+      return "text/markdown";
+    case ".txt":
+      return "text/plain";
+    case ".json":
+      return "application/json";
+    case ".zip":
+      return "application/zip";
+    default:
+      return "application/octet-stream";
+  }
+}
+function streamingPut(uploadUrl, data, mimeType, label) {
+  return new Promise((resolve, reject) => {
+    const url = new URL(uploadUrl);
+    const transport = url.protocol === "https:" ? https : http;
+    const req = transport.request(
+      url,
+      {
+        method: "PUT",
+        headers: {
+          "Content-Type": mimeType,
+          "Content-Length": String(data.length)
+        }
+      },
+      (res) => {
+        const chunks = [];
+        res.on("data", (chunk) => chunks.push(chunk));
+        res.on("end", () => {
+          if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
+            process.stderr.write("\n");
+            resolve();
+          } else {
+            const body = Buffer.concat(chunks).toString("utf8").slice(0, 500);
+            reject(
+              new Error(
+                `Upload failed (${res.statusCode ?? "unknown"}): ${body || "no response body"}`
+              )
+            );
+          }
+        });
+      }
+    );
+    req.on("error", reject);
+    let uploaded = 0;
+    const stream = Readable.from([data]);
+    stream.on("data", (chunk) => {
+      uploaded += chunk.length;
+      const pct = Math.round(uploaded / data.length * 100);
+      process.stderr.write(`\r  ${label}: ${pct}%`);
+    });
+    stream.on("error", reject);
+    stream.pipe(req);
   });
-  printResult({ submissionId: result.submissionId });
+}
+var submitCmd = new Command8("submit").description("Submit work for a task").argument("<taskId>", "Task ID (0x-prefixed hex)").option("--file <path>", "Path to a submission file (repeatable)", collectFile, []).addOption(
+  new Option("--role <role>", "Artifact role applied to all files").choices(["preview", "source", "final", "attachment"]).default("attachment")
+).action(async (taskId, opts) => {
+  try {
+    if (!opts.file || opts.file.length === 0) {
+      printError("--file is required");
+    }
+    const keystore = await loadKeystore();
+    const signature = await signMessage(`taskmarket:submit:${taskId}`, keystore);
+    const artifactInputs = await Promise.all(
+      opts.file.map(async (filePath) => {
+        const mimeType = mimeTypeForPath(filePath);
+        const data = await fsPromises.readFile(filePath);
+        if (data.length === 0) {
+          printError(`File is empty: ${basename(filePath)}`);
+        }
+        const { uploadUrl, artifactKey } = await apiPost(
+          `/api/tasks/${taskId}/submissions/request-upload-url`,
+          {
+            taskId,
+            workerAddress: keystore.walletAddress,
+            signature,
+            fileName: basename(filePath),
+            mimeType,
+            role: opts.role,
+            sizeBytes: data.length
+          }
+        );
+        const sha256Hash = createHash("sha256").update(data).digest("hex");
+        const keccak256Hash = keccak256(new Uint8Array(data));
+        process.stderr.write(`  Uploading ${basename(filePath)}...
+`);
+        await streamingPut(uploadUrl, data, mimeType, basename(filePath));
+        return {
+          artifactKey,
+          fileName: basename(filePath),
+          mimeType,
+          role: opts.role,
+          sizeBytes: data.length,
+          sha256Hash,
+          keccak256Hash
+        };
+      })
+    );
+    const result = await apiPost(`/api/tasks/${taskId}/submissions/from-keys`, {
+      taskId,
+      workerAddress: keystore.walletAddress,
+      artifacts: artifactInputs,
+      signature
+    });
+    printResult({ submissionId: result.submissionId });
+  } finally {
+    submitCmd.setOptionValue("file", []);
+  }
 });
 
 // src/commands/task/accept.ts
 import { Command as Command9 } from "commander";
-var acceptCmd = new Command9("accept").description("Accept a submission (costs 0.001 USDC)").argument("<taskId>", "Task ID (0x-prefixed hex)").requiredOption("--worker <addr>", "Worker wallet address").action(async (taskId, opts) => {
+var acceptCmd = new Command9("accept").description("Accept a submission (costs 0.001 USDC)").argument("<taskId>", "Task ID (0x-prefixed hex)").requiredOption("--worker <addr>", "Worker wallet address").option(
+  "--deliverable <hash>",
+  "Deliverable hash to commit on-chain (32-byte hex). Backend will look it up from the submission if omitted."
+).action(async (taskId, opts) => {
+  if (opts.deliverable && !/^0x[0-9a-fA-F]{64}$/.test(opts.deliverable)) {
+    throw new Error("--deliverable must be a 0x-prefixed 32-byte hex string (0x + 64 hex chars)");
+  }
   await x402Post(`/api/tasks/${taskId}/accept`, {
     taskId,
-    worker: opts.worker
+    worker: opts.worker,
+    ...opts.deliverable ? { deliverable: opts.deliverable } : {}
   });
   printResult({ accepted: true });
 });
 
-// src/commands/task/rate.ts
+// src/commands/task/accept-submissions.ts
 import { Command as Command10 } from "commander";
-var rateCmd = new Command10("rate").description("Rate a worker (costs 0.001 USDC)").argument("<taskId>", "Task ID (0x-prefixed hex)").requiredOption("--worker <addr>", "Worker wallet address").requiredOption("--rating <n>", "Rating 0-100").option("--feedback <text>", "Optional feedback text").action(async (taskId, opts) => {
-  const rating = parseInt(opts.rating, 10);
-  if (rating < 0 || rating > 100) {
-    printError("Rating must be between 0 and 100");
+function parseWinner(spec) {
+  const parts = spec.split(":");
+  if (parts.length < 2 || parts.length > 4) {
+    throw new Error(
+      `Invalid --winner value "${spec}". Expected <addr>:<share>[:<submissionId>][:<deliverable>]`
+    );
+  }
+  const [worker, shareStr, submissionId, deliverable] = parts;
+  if (!/^0x[0-9a-fA-F]{40}$/.test(worker)) {
+    throw new Error(`Invalid worker address in "${spec}"`);
+  }
+  const share = parseInt(shareStr, 10);
+  if (Number.isNaN(share) || share < 1 || share > 1e4) {
+    throw new Error(`Invalid share in "${spec}" \u2014 must be integer 1..10000 (basis points)`);
+  }
+  if (deliverable && !/^0x[0-9a-fA-F]{64}$/.test(deliverable)) {
+    throw new Error(`Invalid deliverable hash in "${spec}" \u2014 must be 0x + 64 hex chars`);
+  }
+  return {
+    worker,
+    share,
+    ...submissionId ? { submissionId } : {},
+    ...deliverable ? { deliverable } : {}
+  };
+}
+var acceptSubmissionsCmd = new Command10("accept-submissions").description(
+  "Accept N submissions for a Bounty/Benchmark task with explicit share basis points (costs 0.001 USDC).\nShares must sum to 10000. The backend resolves each winner's deliverable from the submission row\nif --winner omits the explicit hash.\n\nFor ranked payouts, pass winners in rank order \u2014 workers[0] is the primary winner.\n\nExamples:\n  task accept-submissions 0x\u2026 --winner 0xAlice:5000 --winner 0xBob:3000 --winner 0xCarol:2000\n  task accept-submissions 0x\u2026 --winner 0xAlice:5000:sub-uuid --winner 0xBob:5000:sub-uuid2"
+).argument("<taskId>", "Task ID (0x-prefixed hex)").requiredOption(
+  "--winner <spec...>",
+  "Winner spec <addr>:<share>[:<submissionId>][:<deliverable>]. Pass multiple times."
+).action(async (taskId, opts) => {
+  let winners;
+  try {
+    winners = opts.winner.map(parseWinner);
+  } catch (err) {
+    printError(err instanceof Error ? err.message : String(err));
+    return;
+  }
+  const sum = winners.reduce((a, w) => a + w.share, 0);
+  if (sum !== 1e4) {
+    printError(`Winner shares must sum to 10000 basis points (got ${sum})`);
+    return;
   }
-  const result = await x402Post(`/api/tasks/${taskId}/rate`, {
+  const result = await x402Post(`/api/tasks/${taskId}/accept-submissions`, {
     taskId,
-    worker: opts.worker,
-    rating,
-    ...opts.feedback ? { feedbackText: opts.feedback } : {}
+    winners
   });
-  printResult({ feedbackId: result.feedbackId });
+  printResult({ accepted: result.success, winners: winners.length });
 });
 
-// src/commands/task/claim.ts
+// src/commands/task/rate.ts
 import { Command as Command11 } from "commander";
-var claimCmd = new Command11("claim").description("Claim a task as a worker").argument("<taskId>", "Task ID (0x-prefixed hex)").action(async (taskId) => {
+var rateCmd = new Command11("rate").description("Rate a worker (costs 0.001 USDC)").argument("<taskId>", "Task ID (0x-prefixed hex)").requiredOption("--worker <addr>", "Worker wallet address").requiredOption("--rating <n>", "Rating 0-100").option("--feedback <text>", "Optional feedback text").option(
+  "--rater-agent-id <id>",
+  "ERC-8004 agent ID of the requester (overrides server-side lookup)"
+).action(
+  async (taskId, opts) => {
+    const rating = parseInt(opts.rating, 10);
+    if (rating < 0 || rating > 100) {
+      printError("Rating must be between 0 and 100");
+    }
+    const result = await x402Post(`/api/tasks/${taskId}/rate`, {
+      taskId,
+      worker: opts.worker,
+      rating,
+      ...opts.feedback ? { feedbackText: opts.feedback } : {},
+      ...opts.raterAgentId ? { raterAgentId: parseInt(opts.raterAgentId, 10) } : {}
+    });
+    printResult({ feedbackId: result.feedbackId });
+  }
+);
+
+// src/commands/task/claim.ts
+import { Command as Command12 } from "commander";
+var claimCmd = new Command12("claim").description("Claim a task as a worker").argument("<taskId>", "Task ID (0x-prefixed hex)").action(async (taskId) => {
   const keystore = await loadKeystore();
   const message = `taskmarket:claim:${taskId}`;
   const signature = await signMessage(message, keystore);
@@ -596,11 +888,12 @@ var claimCmd = new Command11("claim").description("Claim a task as a worker").ar
 });
 
 // src/commands/task/pitch.ts
-import { Command as Command12 } from "commander";
-var pitchCmd = new Command12("pitch").description("Submit a pitch for a task").argument("<taskId>", "Task ID (0x-prefixed hex)").requiredOption("--text <text>", "Pitch text").option("--duration <hours>", "Estimated duration in hours").action(async (taskId, opts) => {
+import { Command as Command13 } from "commander";
+var pitchCmd = new Command13("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 result = await apiPost(`/api/tasks/${taskId}/pitches`, {
+  const result = await x402Post(`/api/tasks/${taskId}/pitches`, {
+    taskId,
     workerAddress: keystore.walletAddress,
     pitchText: opts.text,
     ...opts.duration ? { estimatedDuration: parseInt(opts.duration, 10) } : {},
@@ -610,11 +903,11 @@ var pitchCmd = new Command12("pitch").description("Submit a pitch for a task").a
 });
 
 // src/commands/task/select-worker.ts
-import { Command as Command13 } from "commander";
-import { keccak256, toBytes } from "viem";
-var selectWorkerCmd = new Command13("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) => {
+import { Command as Command14 } from "commander";
+import { keccak256 as keccak2562, toBytes } from "viem";
+var selectWorkerCmd = new Command14("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 hash = keccak256(toBytes(taskId + opts.pitch + opts.worker));
+  const hash = keccak2562(toBytes(taskId + opts.pitch + opts.worker));
   const signature = await signMessage(hash, keystore);
   await apiPost(`/api/tasks/${taskId}/pitches/select`, {
     taskId,
@@ -626,11 +919,12 @@ var selectWorkerCmd = new Command13("select-worker").description("Select a worke
 });
 
 // src/commands/task/proof.ts
-import { Command as Command14 } from "commander";
-var proofCmd = new Command14("proof").description("Submit a proof for a task").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) => {
+import { Command as Command15 } from "commander";
+var proofCmd = new Command15("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 result = await apiPost(`/api/tasks/${taskId}/proofs`, {
+  const result = await x402Post(`/api/tasks/${taskId}/proofs`, {
+    taskId,
     workerAddress: keystore.walletAddress,
     proofData: opts.data,
     proofType: opts.type,
@@ -641,8 +935,8 @@ var proofCmd = new Command14("proof").description("Submit a proof for a task").a
 });
 
 // src/commands/task/bid.ts
-import { Command as Command15 } from "commander";
-var bidCmd = new Command15("bid").description("Submit a bid on an auction task").argument("<taskId>", "Task ID (0x-prefixed hex)").requiredOption("--price <usdc>", "Bid price in USDC (e.g. 3 or 1.5)").action(async (taskId, opts) => {
+import { Command as Command16 } from "commander";
+var bidCmd = new Command16("bid").description("Submit a bid on an auction task").argument("<taskId>", "Task ID (0x-prefixed hex)").requiredOption("--price <usdc>", "Bid price in USDC (e.g. 3 or 1.5)").action(async (taskId, opts) => {
   const priceBaseUnits = String(Math.round(parseFloat(opts.price) * 1e6));
   const result = await x402Post(`/api/tasks/${taskId}/bids`, {
     taskId,
@@ -651,9 +945,32 @@ var bidCmd = new Command15("bid").description("Submit a bid on an auction task")
   printResult({ bidId: result.bidId });
 });
 
+// src/commands/task/auction-accept.ts
+import { Command as Command17 } from "commander";
+var auctionAcceptCmd = new Command17("auction-accept").description("Accept current clock price on a dutch or reverse_dutch auction task").argument("<taskId>", "Task ID (0x-prefixed hex)").option(
+  "--min-price <usdc>",
+  "Reject if current clock price is below this value (price floor guard)"
+).action(async (taskId, opts) => {
+  const body = { taskId };
+  if (opts.minPrice) {
+    const [intPart = "0", fracPart = ""] = opts.minPrice.trim().split(".");
+    if (!/^\d+$/.test(intPart) || fracPart && !/^\d+$/.test(fracPart)) {
+      throw new Error(`--min-price: invalid number "${opts.minPrice}"`);
+    }
+    const padded = fracPart.slice(0, 6).padEnd(6, "0");
+    body.minPrice = (BigInt(intPart) * 1000000n + BigInt(padded)).toString();
+  }
+  const result = await x402Post(`/api/tasks/${taskId}/bids/accept`, body);
+  printResult({
+    acceptedPrice: result.acceptedPrice,
+    acceptedPriceUsdc: (Number(result.acceptedPrice) / 1e6).toFixed(6),
+    workerAddress: result.workerAddress
+  });
+});
+
 // src/commands/task/submissions.ts
-import { Command as Command16 } from "commander";
-var submissionsCmd = new Command16("submissions").description("List submissions for a task").argument("<taskId>", "Task ID (0x-prefixed hex)").action(async (taskId) => {
+import { Command as Command18 } from "commander";
+var submissionsCmd = new Command18("submissions").description("List submissions for a task").argument("<taskId>", "Task ID (0x-prefixed hex)").action(async (taskId) => {
   let subs;
   try {
     subs = await apiGet(`/api/tasks/${taskId}/submissions`);
@@ -665,8 +982,8 @@ var submissionsCmd = new Command16("submissions").description("List submissions
 });
 
 // src/commands/task/select-winner.ts
-import { Command as Command17 } from "commander";
-var selectWinnerCmd = new Command17("select-winner").description("Select lowest bidder after auction deadline (requester only)").argument("<taskId>", "Task ID (0x-prefixed hex)").action(async (taskId) => {
+import { Command as Command19 } from "commander";
+var selectWinnerCmd = new Command19("select-winner").description("Select lowest bidder after auction deadline (requester only)").argument("<taskId>", "Task ID (0x-prefixed hex)").action(async (taskId) => {
   let result;
   try {
     result = await apiPost(`/api/tasks/${taskId}/bids/select-winner`, {
@@ -680,56 +997,296 @@ var selectWinnerCmd = new Command17("select-winner").description("Select lowest
 });
 
 // src/commands/task/download.ts
-import { Command as Command18 } from "commander";
+import { Command as Command20 } from "commander";
 import { writeFileSync } from "fs";
-var downloadCmd = new Command18("download").description("Download a submission file (requester or worker)").argument("<taskId>", "Task ID (0x-prefixed hex)").requiredOption("--submission <id>", "Submission ID (from `task submissions`)").option("--output <path>", "Save to file instead of printing to stdout").action(async (taskId, opts) => {
-  const keystore = await loadKeystore();
-  let presignedUrl;
+var downloadCmd = new Command20("download").description("Download a submission file (requester or worker)").argument("<taskId>", "Task ID (0x-prefixed hex)").requiredOption("--submission <id>", "Submission ID (from `task submissions`)").option("--artifact <id>", "Artifact ID for multi-artifact submissions").option("--output <path>", "Save to file instead of printing to stdout").action(
+  async (taskId, opts) => {
+    const keystore = await loadKeystore();
+    let presignedUrl;
+    try {
+      const body = {
+        taskId,
+        submissionId: opts.submission,
+        deviceId: keystore.deviceId,
+        apiToken: keystore.apiToken
+      };
+      if (opts.artifact) {
+        body.artifactId = opts.artifact;
+      }
+      const result = await apiPost(
+        `/api/tasks/${taskId}/submissions/${opts.submission}/preview`,
+        body
+      );
+      presignedUrl = result.presignedUrl;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : "Failed to get download URL.";
+      printError(msg);
+    }
+    const res = await fetch(presignedUrl);
+    if (!res.ok) {
+      printError(`Failed to download file: ${res.status}`);
+    }
+    const content = Buffer.from(await res.arrayBuffer());
+    if (opts.output) {
+      writeFileSync(opts.output, content);
+      process.stdout.write(JSON.stringify({ ok: true, data: { savedTo: opts.output } }) + "\n");
+    } else {
+      process.stdout.write(content);
+    }
+  }
+);
+
+// src/commands/task/cancel.ts
+import { Command as Command21 } from "commander";
+var cancelCmd = new Command21("cancel").description("Cancel an open task and refund the escrowed reward (costs 0.001 USDC)").argument("<taskId>", "Task ID (0x-prefixed hex)").action(async (taskId) => {
+  const result = await x402Post(`/api/tasks/${taskId}/cancel`, { taskId });
+  printResult(result);
+});
+
+// src/commands/task/update.ts
+import { Command as Command22 } from "commander";
+function toBaseUnits(humanUsdc) {
+  const [intPart = "0", fracPart = ""] = humanUsdc.trim().split(".");
+  const padded = fracPart.slice(0, 6).padEnd(6, "0");
+  return (BigInt(intPart) * 1000000n + BigInt(padded)).toString();
+}
+var updateCmd = new Command22("update").description("Update an open task (costs 0.001 USDC)").argument("<taskId>", "Task ID (0x-prefixed hex)").option("--reward <usdc>", 'New reward in USDC (human units, e.g. "50")').option("--extend-expiry <seconds>", "Extend expiry by this many seconds").option("--bid-deadline <iso>", "New bid deadline (ISO 8601)").option("--pitch-deadline <iso>", "New pitch deadline (ISO 8601)").option("--auction-floor-price <usdc>", "New auction floor price in USDC").option("--auction-start-price <usdc>", "New auction start price in USDC").option("--description <text>", "New description").option("--tags <csv>", "New tags (comma-separated)").option("--metric-description <text>", "New metric description").action(
+  async (taskId, opts) => {
+    const body = { taskId };
+    if (opts.reward !== void 0) {
+      body.reward = toBaseUnits(opts.reward);
+    }
+    if (opts.extendExpiry !== void 0) {
+      const delta = parseInt(opts.extendExpiry, 10);
+      if (!Number.isFinite(delta) || delta < 0) {
+        printError(`--extend-expiry must be a non-negative integer, got: ${opts.extendExpiry}`);
+      }
+      const task = await apiGet(`/api/tasks/${taskId}`);
+      if (!task) {
+        printError(`Task not found: ${taskId}`);
+      }
+      const currentExpiry = Math.floor(new Date(task.expiryTime).getTime() / 1e3);
+      body.expiryTime = currentExpiry + delta;
+    }
+    if (opts.bidDeadline !== void 0) {
+      const ts = Math.floor(new Date(opts.bidDeadline).getTime() / 1e3);
+      if (ts <= Math.floor(Date.now() / 1e3)) {
+        printError("--bid-deadline must be in the future");
+      } else {
+        body.bidDeadline = ts;
+      }
+    }
+    if (opts.pitchDeadline !== void 0) {
+      const ts = Math.floor(new Date(opts.pitchDeadline).getTime() / 1e3);
+      if (ts <= Math.floor(Date.now() / 1e3)) {
+        printError("--pitch-deadline must be in the future");
+      } else {
+        body.pitchDeadline = ts;
+      }
+    }
+    if (opts.auctionFloorPrice !== void 0) {
+      body.auctionFloorPrice = toBaseUnits(opts.auctionFloorPrice);
+    }
+    if (opts.auctionStartPrice !== void 0) {
+      body.auctionStartPrice = toBaseUnits(opts.auctionStartPrice);
+    }
+    if (opts.description !== void 0) {
+      body.description = opts.description;
+    }
+    if (opts.tags !== void 0) {
+      body.tags = opts.tags.split(",").map((t) => t.trim()).filter(Boolean);
+    }
+    if (opts.metricDescription !== void 0) {
+      body.metricDescription = opts.metricDescription;
+    }
+    const result = await x402Post(`/api/tasks/${taskId}/update`, body);
+    printResult(result);
+  }
+);
+
+// src/commands/task/forfeit.ts
+import { Command as Command23 } from "commander";
+var forfeitCmd = new Command23("forfeit").description("Reclaim a claim-mode task whose worker's claim has expired (requester only)").argument("<taskId>", "Task ID (0x-prefixed hex)").action(async (taskId) => {
   try {
-    const result = await apiPost(`/api/tasks/${taskId}/submissions/${opts.submission}/preview`, {
+    const keystore = await loadKeystore();
+    const message = `taskmarket:forfeit:${taskId}`;
+    const signature = await signMessage(message, keystore);
+    const result = await apiPost(`/api/tasks/${taskId}/forfeit`, {
       taskId,
-      submissionId: opts.submission,
-      deviceId: keystore.deviceId,
-      apiToken: keystore.apiToken
+      requesterAddress: keystore.walletAddress,
+      signature
     });
-    presignedUrl = result.presignedUrl;
+    printResult(result);
   } catch (err) {
-    const msg = err instanceof Error ? err.message : "Failed to get download URL.";
-    printError(msg);
+    printError(err instanceof Error ? err.message : String(err));
   }
-  const res = await fetch(presignedUrl);
-  if (!res.ok) {
-    printError(`Failed to download file: ${res.status}`);
+});
+
+// src/commands/task/evaluate.ts
+import { Command as Command24 } from "commander";
+var evaluateCmd = new Command24("evaluate").description("Submit an evaluation verdict for a task in Review state").argument("<taskId>", "Task ID (0x-prefixed hex)").requiredOption("--verdict <type>", "Verdict: approve, reject, or partial").option("--score <n>", "Score 0-1000 (default: 1000)", "1000").option("--confidence <n>", "Confidence 0-1000 (default: 1000)", "1000").option("--evidence-hash <hash>", "Evidence hash (32-byte hex)").option(
+  "--award <worker:amount:rank>",
+  "Award entry (repeatable): worker:amountUSDC:rank",
+  collect,
+  []
+).action(
+  async (taskId, opts) => {
+    const validVerdicts = ["approve", "reject", "partial"];
+    if (!validVerdicts.includes(opts.verdict)) {
+      return void printError(`--verdict must be one of: ${validVerdicts.join(", ")}`);
+    }
+    const awards = [];
+    for (const entry of opts.award) {
+      const parts = entry.split(":");
+      if (parts.length < 3 || !parts[0] || !parts[1] || !parts[2]) {
+        return void printError(
+          `Invalid award format '${entry}'. Expected worker:amountUSDC:rank`
+        );
+      }
+      const [worker, amountUSDC, rankStr] = parts;
+      if (!/^0x[0-9a-fA-F]{40}$/.test(worker)) {
+        return void printError(
+          `Invalid worker address in '${entry}': must be 0x-prefixed 40-char hex`
+        );
+      }
+      const parsedAmount = Number(amountUSDC);
+      if (!Number.isFinite(parsedAmount) || parsedAmount <= 0) {
+        return void printError(`Invalid amount in '${entry}': must be a positive number`);
+      }
+      const microUnits = Math.round(parsedAmount * 1e6);
+      if (!Number.isFinite(microUnits) || microUnits > Number.MAX_SAFE_INTEGER) {
+        return void printError(`Amount in '${entry}' is too large to convert to micro-units`);
+      }
+      const parsedRank = Number(rankStr);
+      if (!Number.isInteger(parsedRank) || parsedRank < 1) {
+        return void printError(`Invalid rank in '${entry}': must be a positive integer`);
+      }
+      awards.push({ worker, amount: String(microUnits), rank: parsedRank });
+    }
+    const body = {
+      taskId,
+      verdict: opts.verdict,
+      score: parseInt(opts.score, 10),
+      confidence: parseInt(opts.confidence, 10),
+      awards
+    };
+    if (opts.evidenceHash) {
+      if (!/^0x[0-9a-fA-F]{64}$/.test(opts.evidenceHash)) {
+        return void printError(
+          "--evidence-hash must be a 0x-prefixed 32-byte hex string (0x + 64 hex chars)"
+        );
+      }
+      body.evidenceHash = opts.evidenceHash;
+    }
+    const result = await x402Post(`/api/tasks/${taskId}/evaluate`, body);
+    printResult({ txHash: result.txHash });
   }
-  const content = await res.text();
-  if (opts.output) {
-    writeFileSync(opts.output, content, "utf8");
-    process.stdout.write(JSON.stringify({ ok: true, data: { savedTo: opts.output } }) + "\n");
-  } else {
-    process.stdout.write(content);
+);
+function collect(val, prev) {
+  return prev.concat([val]);
+}
+
+// src/commands/task/appeal.ts
+import { Command as Command25 } from "commander";
+var appealCmd = new Command25("appeal").description("Appeal an evaluator verdict while in Appealing state").argument("<taskId>", "Task ID (0x-prefixed hex)").action(async (taskId) => {
+  const result = await x402Post(`/api/tasks/${taskId}/appeal`, { taskId });
+  printResult({ txHash: result.txHash });
+});
+
+// src/commands/task/evaluator-timeout.ts
+import { Command as Command26 } from "commander";
+var evaluatorTimeoutCmd = new Command26("evaluator-timeout").description("Trigger evaluator timeout after the evaluation window expires (requester only)").argument("<taskId>", "Task ID (0x-prefixed hex)").action(async (taskId) => {
+  const result = await x402Post(`/api/tasks/${taskId}/evaluator-timeout`, { taskId });
+  printResult({ txHash: result.txHash });
+});
+
+// src/commands/task/finalize-verdict.ts
+import { Command as Command27 } from "commander";
+var finalizeVerdictCmd = new Command27("finalize-verdict").description("Finalize an evaluator verdict after the appeal window expires (permissionless)").argument("<taskId>", "Task ID (0x-prefixed hex)").action(async (taskId) => {
+  const result = await x402Post(`/api/tasks/${taskId}/finalize-verdict`, { taskId });
+  printResult({ txHash: result.txHash });
+});
+
+// src/commands/task/resolve-dispute.ts
+import { Command as Command28 } from "commander";
+function parseAward(spec) {
+  const parts = spec.split(":");
+  if (parts.length !== 3) {
+    throw new Error(`Invalid --award value "${spec}". Expected <addr>:<amount_usdc>:<rank>`);
+  }
+  const [worker, amountStr, rankStr] = parts;
+  if (!/^0x[0-9a-fA-F]{40}$/.test(worker)) {
+    throw new Error(`Invalid worker address in "${spec}"`);
+  }
+  const amount = parseFloat(amountStr);
+  if (Number.isNaN(amount) || amount <= 0) {
+    throw new Error(`Invalid amount in "${spec}" \u2014 must be a positive number`);
+  }
+  const rank = parseInt(rankStr, 10);
+  if (!Number.isInteger(rank) || rank < 1) {
+    throw new Error(`Invalid rank in "${spec}" \u2014 must be an integer >= 1`);
+  }
+  return {
+    worker,
+    amount: String(Math.round(amount * 1e6)),
+    rank
+  };
+}
+var resolveDisputeCmd = new Command28("resolve-dispute").description(
+  "Resolve a disputed task as the designated dispute resolver (X402 required).\n\nExamples:\n  task resolve-dispute 0x\u2026 --verdict approve --award 0xAlice:5:1\n  task resolve-dispute 0x\u2026 --verdict partial --award 0xAlice:3:1 --award 0xBob:2:2"
+).argument("<taskId>", "Task ID (0x-prefixed hex)").requiredOption("--verdict <type>", "Verdict type: approve or partial").requiredOption(
+  "--award <spec...>",
+  "Award spec <addr>:<amount_usdc>:<rank>. Pass multiple times."
+).action(async (taskId, opts) => {
+  if (opts.verdict !== "approve" && opts.verdict !== "partial") {
+    printError('--verdict must be "approve" or "partial"');
+    return;
+  }
+  let awards;
+  try {
+    awards = opts.award.map(parseAward);
+  } catch (err) {
+    printError(err instanceof Error ? err.message : String(err));
+    return;
   }
+  const result = await x402Post(`/api/tasks/${taskId}/resolve-dispute`, {
+    taskId,
+    verdict: opts.verdict,
+    awards
+  });
+  printResult({ txHash: result.txHash });
 });
 
 // src/commands/task/index.ts
-var taskCommand = new Command19("task").description("Manage tasks");
+var taskCommand = new Command29("task").description("Manage tasks");
 taskCommand.addCommand(createCmd);
 taskCommand.addCommand(listCmd);
 taskCommand.addCommand(getCmd);
 taskCommand.addCommand(submitCmd);
 taskCommand.addCommand(acceptCmd);
+taskCommand.addCommand(acceptSubmissionsCmd);
 taskCommand.addCommand(rateCmd);
 taskCommand.addCommand(claimCmd);
 taskCommand.addCommand(pitchCmd);
 taskCommand.addCommand(selectWorkerCmd);
 taskCommand.addCommand(proofCmd);
 taskCommand.addCommand(bidCmd);
+taskCommand.addCommand(auctionAcceptCmd);
 taskCommand.addCommand(submissionsCmd);
 taskCommand.addCommand(selectWinnerCmd);
 taskCommand.addCommand(downloadCmd);
+taskCommand.addCommand(cancelCmd);
+taskCommand.addCommand(updateCmd);
+taskCommand.addCommand(forfeitCmd);
+taskCommand.addCommand(evaluateCmd);
+taskCommand.addCommand(appealCmd);
+taskCommand.addCommand(evaluatorTimeoutCmd);
+taskCommand.addCommand(finalizeVerdictCmd);
+taskCommand.addCommand(resolveDisputeCmd);
 
 // src/commands/agents.ts
-import { Command as Command20 } from "commander";
-var agentsCommand = new Command20("agents").description("Browse the agent directory").option("--sort <order>", "Sort order: reputation or tasks", "reputation").option("--skill <tag>", "Filter by skill tag").option("--search <query>", "Search by agentId or wallet address").option("--limit <n>", "Maximum results to return", "20").action(async (opts) => {
+import { Command as Command30 } from "commander";
+var agentsCommand = new Command30("agents").description("Browse the agent directory").option("--sort <order>", "Sort order: reputation or tasks", "reputation").option("--skill <tag>", "Filter by skill tag").option("--search <query>", "Search by agentId or wallet address").option("--limit <n>", "Maximum results to return", "20").action(async (opts) => {
   const params = new URLSearchParams();
   if (opts.sort) params.set("sort", opts.sort);
   if (opts.skill) params.set("skill", opts.skill);
@@ -740,8 +1297,8 @@ var agentsCommand = new Command20("agents").description("Browse the agent direct
 });
 
 // src/commands/inbox.ts
-import { Command as Command21 } from "commander";
-var inboxCommand = new Command21("inbox").description("Show tasks you created and tasks you are working on").action(async () => {
+import { Command as Command31 } from "commander";
+var inboxCommand = new Command31("inbox").description("Show tasks you created and tasks you are working on").action(async () => {
   let address;
   try {
     address = await getWalletAddress();
@@ -749,15 +1306,26 @@ var inboxCommand = new Command21("inbox").description("Show tasks you created an
     const msg = err instanceof Error ? err.message : "No keystore found. Run `taskmarket init` first.";
     printError(msg);
   }
-  const result = await apiGet(
+  const taskResult = await apiGet(
     `/api/agents/inbox?address=${encodeURIComponent(address)}`
   );
-  printResult(result);
+  let pendingBids = [];
+  try {
+    const keystore = await loadKeystore();
+    if (keystore.deviceId && keystore.apiToken) {
+      const params = new URLSearchParams({ deviceId: keystore.deviceId });
+      pendingBids = await apiGet(`/api/bids/my?${params.toString()}`, {
+        headers: { "x-taskmarket-api-token": keystore.apiToken }
+      });
+    }
+  } catch {
+  }
+  printResult({ ...taskResult, pendingBids });
 });
 
 // src/commands/deposit.ts
-import { Command as Command22 } from "commander";
-var depositCommand = new Command22("deposit").description("Show wallet address and network info for funding").action(async () => {
+import { Command as Command32 } from "commander";
+var depositCommand = new Command32("deposit").description("Show wallet address and network info for funding").action(async () => {
   let address;
   try {
     address = await getWalletAddress();
@@ -784,11 +1352,11 @@ var depositCommand = new Command22("deposit").description("Show wallet address a
 });
 
 // src/commands/wallet/index.ts
-import { Command as Command27 } from "commander";
+import { Command as Command37 } from "commander";
 
 // src/commands/wallet/balance.ts
-import { Command as Command23 } from "commander";
-var walletBalanceCommand = new Command23("balance").description("Show USDC balance").option("--address <addr>", "Address to check (defaults to own wallet)").action(async (opts) => {
+import { Command as Command33 } from "commander";
+var walletBalanceCommand = new Command33("balance").description("Show USDC balance").option("--address <addr>", "Address to check (defaults to own wallet)").action(async (opts) => {
   let address = opts.address;
   if (!address) {
     const keystore = await loadKeystore();
@@ -799,7 +1367,7 @@ var walletBalanceCommand = new Command23("balance").description("Show USDC balan
 });
 
 // src/commands/wallet/import.ts
-import { Command as Command24 } from "commander";
+import { Command as Command34 } from "commander";
 import { createInterface } from "readline";
 import { privateKeyToAccount as privateKeyToAccount3 } from "viem/accounts";
 function normalizePrivateKey(raw) {
@@ -834,7 +1402,7 @@ function promptHiddenInput(prompt) {
     });
   });
 }
-var walletImportCommand = new Command24("import").description("Import an existing private key as the agent wallet").option("--key <privateKey>", "Private key to import (64 hex chars, with or without 0x prefix)").action(async (opts) => {
+var walletImportCommand = new Command34("import").description("Import an existing private key as the agent wallet").option("--key <privateKey>", "Private key to import (64 hex chars, with or without 0x prefix)").action(async (opts) => {
   if (await keystoreExists()) {
     const keystore = await loadKeystore();
     printResult({ address: keystore.walletAddress, agentId: keystore.agentId });
@@ -873,7 +1441,14 @@ var walletImportCommand = new Command24("import").description("Import an existin
   } = await res.json();
   const encryptedKey = encryptPrivateKey(deviceEncryptionKey, privateKey);
   let agentId = initialAgentId;
-  await saveKeystore({ encryptedKey, walletAddress: address, deviceId, apiToken, agentId });
+  await saveKeystore({
+    encryptedKey,
+    walletAddress: address,
+    deviceId,
+    apiToken,
+    agentId,
+    keyServerUrl: API_URL
+  });
   if (!agentId) {
     agentId = await pollAgentId(address);
     if (agentId) {
@@ -892,11 +1467,11 @@ var walletImportCommand = new Command24("import").description("Import an existin
 });
 
 // src/commands/wallet/set-withdrawal-address.ts
-import { Command as Command25 } from "commander";
+import { Command as Command35 } from "commander";
 function isValidAddress(addr) {
   return /^0x[a-fA-F0-9]{40}$/.test(addr);
 }
-var setWithdrawalAddressCommand = new Command25("set-withdrawal-address").description("Set a withdrawal address for USDC withdrawals (one-time, free)").argument("<address>", "Ethereum address to receive withdrawals").action(async (address) => {
+var setWithdrawalAddressCommand = new Command35("set-withdrawal-address").description("Set a withdrawal address for USDC withdrawals (one-time, free)").argument("<address>", "Ethereum address to receive withdrawals").action(async (address) => {
   if (!isValidAddress(address)) {
     printError("Invalid Ethereum address: must be 0x followed by 40 hex characters");
   }
@@ -918,8 +1493,8 @@ var setWithdrawalAddressCommand = new Command25("set-withdrawal-address").descri
 });
 
 // src/commands/wallet/publish-key.ts
-import { Command as Command26 } from "commander";
-var publishKeyCommand = new Command26("publish-key").description("Publish your secp256k1 public key so others can encrypt files for you").action(async () => {
+import { Command as Command36 } from "commander";
+var publishKeyCommand = new Command36("publish-key").description("Publish your secp256k1 public key so others can encrypt files for you").action(async () => {
   let keystore;
   try {
     keystore = await loadKeystore();
@@ -938,14 +1513,14 @@ var publishKeyCommand = new Command26("publish-key").description("Publish your s
 });
 
 // src/commands/wallet/index.ts
-var walletCommand = new Command27("wallet").description("Wallet management commands");
+var walletCommand = new Command37("wallet").description("Wallet management commands");
 walletCommand.addCommand(walletBalanceCommand);
 walletCommand.addCommand(walletImportCommand);
 walletCommand.addCommand(setWithdrawalAddressCommand);
 walletCommand.addCommand(publishKeyCommand);
 
 // src/commands/withdraw.ts
-import { Command as Command28 } from "commander";
+import { Command as Command38 } from "commander";
 import { toHex as toHex2 } from "viem";
 var USDC_TYPES = {
   TransferWithAuthorization: [
@@ -957,7 +1532,7 @@ var USDC_TYPES = {
     { name: "nonce", type: "bytes32" }
   ]
 };
-var withdrawCommand = new Command28("withdraw").description("Withdraw USDC to the registered withdrawal address").argument("<amount>", "Amount in USDC (e.g. 5 for 5 USDC)").action(async (amount) => {
+var withdrawCommand = new Command38("withdraw").description("Withdraw USDC to the registered withdrawal address").argument("<amount>", "Amount in USDC (e.g. 5 for 5 USDC)").action(async (amount) => {
   const parsed = parseFloat(amount);
   if (isNaN(parsed) || parsed <= 0) {
     printError("Invalid amount: must be a positive number (e.g. 5 for 5 USDC)");
@@ -1007,12 +1582,12 @@ var withdrawCommand = new Command28("withdraw").description("Withdraw USDC to th
 });
 
 // src/commands/encrypt.ts
-import { Command as Command29 } from "commander";
-import { promises as fs3 } from "fs";
-var encryptCommand = new Command29("encrypt").description("Encrypt a file with ECIES using wallet keys").argument("<file>", "Path to the file to encrypt").option("--recipient <address>", "Recipient wallet address (default: self)").option("--output <path>", "Output path (default: <file>.enc)").action(async (file, opts) => {
+import { Command as Command39 } from "commander";
+import { promises as fs2 } from "fs";
+var encryptCommand = new Command39("encrypt").description("Encrypt a file with ECIES using wallet keys").argument("<file>", "Path to the file to encrypt").option("--recipient <address>", "Recipient wallet address (default: self)").option("--output <path>", "Output path (default: <file>.enc)").action(async (file, opts) => {
   let plaintext;
   try {
-    plaintext = await fs3.readFile(file);
+    plaintext = await fs2.readFile(file);
   } catch {
     printError(`Cannot read file: ${file}`);
   }
@@ -1049,7 +1624,7 @@ var encryptCommand = new Command29("encrypt").description("Encrypt a file with E
   }
   const encrypted = encryptForRecipient(plaintext, recipientPubKey);
   const outputPath = opts.output ?? `${file}.enc`;
-  await fs3.writeFile(outputPath, encrypted);
+  await fs2.writeFile(outputPath, encrypted);
   printResult({
     output: outputPath,
     bytes: encrypted.length,
@@ -1058,12 +1633,12 @@ var encryptCommand = new Command29("encrypt").description("Encrypt a file with E
 });
 
 // src/commands/decrypt.ts
-import { Command as Command30 } from "commander";
-import { promises as fs4 } from "fs";
-var decryptCommand = new Command30("decrypt").description("Decrypt a file using your wallet key").argument("<file>", "Path to the encrypted file").option("--output <path>", "Output path (default: strips .enc, otherwise appends .dec)").action(async (file, opts) => {
+import { Command as Command40 } from "commander";
+import { promises as fs3 } from "fs";
+var decryptCommand = new Command40("decrypt").description("Decrypt a file using your wallet key").argument("<file>", "Path to the encrypted file").option("--output <path>", "Output path (default: strips .enc, otherwise appends .dec)").action(async (file, opts) => {
   let ciphertext;
   try {
-    ciphertext = await fs4.readFile(file);
+    ciphertext = await fs3.readFile(file);
   } catch {
     printError(`Cannot read file: ${file}`);
   }
@@ -1090,7 +1665,7 @@ var decryptCommand = new Command30("decrypt").description("Decrypt a file using
   } else {
     outputPath = `${file}.dec`;
   }
-  await fs4.writeFile(outputPath, plaintext);
+  await fs3.writeFile(outputPath, plaintext);
   printResult({
     output: outputPath,
     bytes: plaintext.length
@@ -1098,7 +1673,7 @@ var decryptCommand = new Command30("decrypt").description("Decrypt a file using
 });
 
 // src/commands/xmtp.ts
-import { Command as Command31 } from "commander";
+import { Command as Command41 } from "commander";
 
 // src/lib/xmtp-client.ts
 import os2 from "os";
@@ -5157,11 +5732,14 @@ var TaskStatus = external_exports.enum([
   "claimed",
   "worker_selected",
   "pending_approval",
-  "accepted",
+  "review",
+  "appealing",
+  "disputed",
   "completed",
   "expired",
-  "disputed"
+  "cancelled"
 ]);
+var AuctionType = external_exports.enum(["dutch", "english", "reverse_dutch", "reverse_english"]);
 var TaskCreateSchema = external_exports.object({
   description: external_exports.string().min(1, "Description is required").max(2e3, "Description is too long"),
   reward: external_exports.string().min(1, "Reward is required"),
@@ -5174,7 +5752,17 @@ var TaskCreateSchema = external_exports.object({
   bidDeadline: external_exports.number().positive().optional(),
   maxPrice: external_exports.string().optional(),
   metricDescription: external_exports.string().max(500).optional(),
-  metricTarget: external_exports.string().max(200).optional()
+  metricTarget: external_exports.string().max(200).optional(),
+  auctionType: AuctionType.optional(),
+  auctionStartPrice: external_exports.string().optional(),
+  auctionFloorPrice: external_exports.string().optional(),
+  hookContract: external_exports.string().optional(),
+  hookData: external_exports.string().regex(/^0x(?:[0-9a-fA-F]{2})*$/, "hookData must be hex-encoded bytes (0x followed by pairs of hex digits)").optional(),
+  evaluator: external_exports.string().optional(),
+  evaluatorFeeBps: external_exports.number().min(0).max(1e4).optional(),
+  evaluationWindowHours: external_exports.number().positive().optional(),
+  appealWindowHours: external_exports.number().positive().optional(),
+  disputeResolver: external_exports.string().optional()
 });
 var TaskResponseSchema = external_exports.object({
   id: external_exports.string(),
@@ -5203,23 +5791,38 @@ var TaskResponseSchema = external_exports.object({
   submissionCount: external_exports.number().optional().default(0),
   pitchCount: external_exports.number().optional().default(0),
   requesterAgentId: external_exports.string().nullable().optional(),
-  workerAgentId: external_exports.string().nullable().optional()
+  requesterActorType: external_exports.enum(["agent", "human"]).optional(),
+  workerAgentId: external_exports.string().nullable().optional(),
+  workerActorType: external_exports.enum(["agent", "human"]).optional(),
+  auctionType: AuctionType.nullable().optional(),
+  auctionStartPrice: external_exports.string().nullable().optional(),
+  auctionFloorPrice: external_exports.string().nullable().optional(),
+  currentAuctionPrice: external_exports.string().nullable().optional(),
+  auctionBidCount: external_exports.number().nullable().optional(),
+  auctionPriceReachesFloorAt: external_exports.string().nullable().optional(),
+  auctionPriceReachesMaxAt: external_exports.string().nullable().optional(),
+  currentLowestBid: external_exports.string().nullable().optional(),
+  hookContract: external_exports.string().nullable().optional(),
+  evaluator: external_exports.string().nullable().optional(),
+  evaluatorStake: external_exports.string().nullable().optional(),
+  evaluatorFeeBps: external_exports.number().nullable().optional(),
+  evaluationWindow: external_exports.number().nullable().optional(),
+  appealWindow: external_exports.number().nullable().optional(),
+  disputeResolver: external_exports.string().nullable().optional(),
+  appealDeadline: external_exports.string().nullable().optional(),
+  evaluatorDeadline: external_exports.string().nullable().optional(),
+  verdictType: external_exports.enum(["APPROVE", "REJECT", "PARTIAL"]).nullable().optional(),
+  verdictScore: external_exports.number().nullable().optional(),
+  verdictConfidence: external_exports.number().nullable().optional(),
+  verdictEvidenceHash: external_exports.string().nullable().optional()
 });
 var TaskListInputSchema = external_exports.object({
   limit: external_exports.number().min(1).max(100).optional().default(20),
   cursor: external_exports.string().optional(),
-  status: external_exports.enum([
-    "ALL",
-    "open",
-    "claimed",
-    "worker_selected",
-    "pending_approval",
-    "accepted",
-    "completed",
-    "expired",
-    "disputed"
-  ]).optional().default("ALL"),
+  status: external_exports.union([TaskStatus, external_exports.literal("ALL")]).optional().default("ALL"),
   mode: external_exports.enum(["ALL", "bounty", "claim", "pitch", "benchmark", "auction"]).optional().default("ALL"),
+  auctionType: AuctionType.optional(),
+  requesterActorType: external_exports.enum(["agent", "human"]).optional(),
   tags: external_exports.array(external_exports.string()).optional(),
   minReward: external_exports.string().optional(),
   maxReward: external_exports.string().optional(),
@@ -5237,20 +5840,88 @@ var TaskInboxResponseSchema = external_exports.object({
   asRequester: external_exports.array(TaskResponseSchema),
   asWorker: external_exports.array(TaskResponseSchema)
 });
+var PendingActionName = external_exports.enum([
+  "accept",
+  "appeal",
+  "auction_accept",
+  "bid",
+  "cancel",
+  "claim",
+  "evaluate",
+  "evaluator_timeout",
+  "finalize_verdict",
+  "forfeit",
+  "pitch",
+  "rate",
+  "resolve_dispute",
+  "select_winner",
+  "select_worker",
+  "submit",
+  "submit_proof",
+  "update"
+]);
 var PendingActionSchema = external_exports.object({
-  role: external_exports.enum(["requester", "worker"]),
-  action: external_exports.string(),
+  role: external_exports.enum(["requester", "worker", "evaluator", "dispute_resolver", "anyone"]),
+  action: PendingActionName,
   command: external_exports.string()
 });
 var TaskDetailResponseSchema = TaskResponseSchema.extend({
   pendingActions: PendingActionSchema.array()
 });
+var CancelTaskInputSchema = external_exports.object({
+  taskId: external_exports.string()
+});
+var UpdateTaskInputSchema = external_exports.object({
+  taskId: external_exports.string(),
+  reward: external_exports.string().optional(),
+  expiryTime: external_exports.number().optional(),
+  bidDeadline: external_exports.number().optional(),
+  pitchDeadline: external_exports.number().optional(),
+  auctionFloorPrice: external_exports.string().optional(),
+  auctionStartPrice: external_exports.string().optional(),
+  description: external_exports.string().max(2e3, "Description is too long").optional(),
+  tags: external_exports.array(external_exports.string()).max(10, "Maximum 10 tags allowed").optional(),
+  metricDescription: external_exports.string().max(500).optional()
+});
 
 // ../../packages/shared/dist/schemas/submission.schemas.js
+var ArtifactRole = external_exports.enum(["preview", "source", "final", "attachment"]);
+var ArtifactMediaKind = external_exports.enum([
+  "image",
+  "video",
+  "audio",
+  "pdf",
+  "text",
+  "archive",
+  "unknown"
+]);
+var ArtifactCreateSchema = external_exports.object({
+  fileName: external_exports.string().min(1, "File name is required").max(255, "File name is too long"),
+  mimeType: external_exports.string().min(1, "MIME type is required").max(120, "MIME type is too long"),
+  role: ArtifactRole.optional().default("attachment"),
+  file: external_exports.string().min(1, "File is required")
+});
+var ArtifactResponseSchema = external_exports.object({
+  id: external_exports.string(),
+  taskId: external_exports.string(),
+  submissionId: external_exports.string(),
+  workerAddress: external_exports.string(),
+  workerAgentId: external_exports.string().nullable(),
+  role: ArtifactRole,
+  fileName: external_exports.string(),
+  mimeType: external_exports.string(),
+  mediaKind: ArtifactMediaKind,
+  storageUri: external_exports.string(),
+  sizeBytes: external_exports.number(),
+  sha256Hash: external_exports.string(),
+  keccak256Hash: external_exports.string(),
+  displayOrder: external_exports.number(),
+  textPreview: external_exports.string().optional()
+});
 var SubmissionCreateSchema = external_exports.object({
   taskId: external_exports.string(),
   workerAddress: external_exports.string(),
-  file: external_exports.string().min(1, "File is required"),
+  artifacts: external_exports.array(ArtifactCreateSchema).min(1).max(20),
   signature: external_exports.string()
 });
 var SubmissionResponseSchema = external_exports.object({
@@ -5261,6 +5932,9 @@ var SubmissionResponseSchema = external_exports.object({
   signature: external_exports.string(),
   submittedAt: external_exports.string(),
   workerAgentId: external_exports.string().nullable().optional(),
+  deliverableHash: external_exports.string().nullable().optional(),
+  submitTxHash: external_exports.string().nullable().optional(),
+  artifacts: external_exports.array(ArtifactResponseSchema).optional().default([]),
   workerStats: external_exports.object({
     completedTasks: external_exports.number(),
     ratedTasks: external_exports.number(),
@@ -5269,18 +5943,51 @@ var SubmissionResponseSchema = external_exports.object({
   }).nullable().optional()
 });
 var DownloadRequestSchema = external_exports.object({
-  acceptanceTxHash: external_exports.string()
+  acceptanceTxHash: external_exports.string(),
+  artifactId: external_exports.string().optional()
 });
 var DownloadResponseSchema = external_exports.object({
   fileUrl: external_exports.string(),
   keyBundle: external_exports.string().nullable().optional(),
   expiresAt: external_exports.string()
 });
+var MAX_ARTIFACT_BYTES = 500 * 1024 * 1024;
+var RequestUploadUrlInputSchema = external_exports.object({
+  taskId: external_exports.string(),
+  workerAddress: external_exports.string(),
+  signature: external_exports.string(),
+  fileName: external_exports.string().min(1, "File name is required").max(255, "File name is too long"),
+  mimeType: external_exports.string().min(1, "MIME type is required").max(120, "MIME type is too long"),
+  role: ArtifactRole.optional().default("attachment"),
+  sizeBytes: external_exports.number().int().positive("Size must be positive").max(MAX_ARTIFACT_BYTES, "File must not exceed 500 MB")
+});
+var RequestUploadUrlOutputSchema = external_exports.object({
+  uploadUrl: external_exports.string(),
+  artifactKey: external_exports.string()
+});
+var ArtifactKeyInputSchema = external_exports.object({
+  artifactKey: external_exports.string().min(1, "Artifact key is required"),
+  fileName: external_exports.string().min(1, "File name is required").max(255, "File name is too long"),
+  mimeType: external_exports.string().min(1, "MIME type is required").max(120, "MIME type is too long"),
+  role: ArtifactRole.optional().default("attachment"),
+  sizeBytes: external_exports.number().int().positive("Size must be positive").max(MAX_ARTIFACT_BYTES, "File must not exceed 500 MB"),
+  sha256Hash: external_exports.string().regex(/^[0-9a-f]{64}$/, "sha256Hash must be 64 lowercase hex chars"),
+  keccak256Hash: external_exports.string().regex(/^0x[0-9a-fA-F]{64}$/, "keccak256Hash must be 0x followed by 64 hex chars")
+});
+var SubmissionCreateFromKeysSchema = external_exports.object({
+  taskId: external_exports.string(),
+  workerAddress: external_exports.string(),
+  artifacts: external_exports.array(ArtifactKeyInputSchema).min(1).max(20),
+  signature: external_exports.string()
+});
 
 // ../../packages/shared/dist/schemas/agent.schemas.js
+var ActorType = external_exports.enum(["agent", "human"]);
+var RegistrationSource = external_exports.enum(["cli", "web"]);
 var AgentStatsSchema = external_exports.object({
   address: external_exports.string(),
   agentId: external_exports.string().nullable().optional(),
+  actorType: ActorType.optional(),
   completedTasks: external_exports.number(),
   ratedTasks: external_exports.number(),
   totalStars: external_exports.number(),
@@ -5288,12 +5995,18 @@ var AgentStatsSchema = external_exports.object({
   totalEarnings: external_exports.string(),
   skills: external_exports.array(external_exports.string()).optional(),
   emailAddress: external_exports.string().nullable().optional(),
+  credibility: external_exports.number().int().min(0).max(1e3).optional(),
   recentRatings: external_exports.array(external_exports.object({
     taskId: external_exports.string(),
     rating: external_exports.number(),
-    createdAt: external_exports.string()
+    createdAt: external_exports.string(),
+    taskTitle: external_exports.string().nullable().optional(),
+    feedbackText: external_exports.string().nullable().optional()
   })).optional()
 });
+var AgentRegistrationInputSchema = external_exports.object({
+  source: RegistrationSource.optional().default("cli")
+});
 var LeaderboardInputSchema = external_exports.object({
   limit: external_exports.number().optional().default(20),
   offset: external_exports.number().optional().default(0),
@@ -5301,17 +6014,20 @@ var LeaderboardInputSchema = external_exports.object({
   skill: external_exports.string().optional(),
   search: external_exports.string().optional(),
   minRating: external_exports.number().min(0).max(5).optional(),
-  minTasks: external_exports.number().int().min(0).optional()
+  minTasks: external_exports.number().int().min(0).optional(),
+  actorType: ActorType.optional()
 });
 var LeaderboardEntrySchema = external_exports.object({
   rank: external_exports.number(),
   address: external_exports.string(),
   agentId: external_exports.string().nullable(),
+  actorType: ActorType.optional(),
   completedTasks: external_exports.number(),
   averageRating: external_exports.number(),
   totalEarnings: external_exports.string(),
   skills: external_exports.array(external_exports.string()),
-  emailAddress: external_exports.string().nullable().optional()
+  emailAddress: external_exports.string().nullable().optional(),
+  credibility: external_exports.number().int().min(0).max(1e3).optional()
 });
 var LeaderboardResponseSchema = external_exports.array(LeaderboardEntrySchema);
 
@@ -5320,7 +6036,8 @@ var RatingInputSchema = external_exports.object({
   taskId: external_exports.string(),
   worker: external_exports.string(),
   rating: external_exports.number().int().min(0).max(100),
-  feedbackText: external_exports.string().max(500).optional()
+  feedbackText: external_exports.string().max(500).optional(),
+  raterAgentId: external_exports.number().int().nonnegative().optional()
 });
 var FeedbackSchema = external_exports.object({
   id: external_exports.string(),
@@ -5390,7 +6107,16 @@ var ClaimResponseSchema = external_exports.object({
 });
 
 // ../../packages/shared/dist/schemas/proof.schemas.js
-var ProofType = external_exports.enum(["url", "screenshot", "api_data", "manual"]);
+var ProofType = external_exports.enum([
+  "url",
+  "screenshot",
+  "api_data",
+  "manual",
+  "custom",
+  "eval",
+  "tlsn",
+  "zk"
+]);
 var ProofStatus = external_exports.enum(["pending", "verified", "rejected"]);
 var ProofSubmitSchema = external_exports.object({
   taskId: external_exports.string().min(1, "Task ID is required"),
@@ -5417,13 +6143,18 @@ var BidCreateSchema = external_exports.object({
   taskId: external_exports.string().min(1, "Task ID is required"),
   price: external_exports.string().min(1, "Price is required")
 });
+var AuctionAcceptSchema = external_exports.object({
+  taskId: external_exports.string().min(1, "Task ID is required"),
+  minPrice: external_exports.string().optional()
+});
 var BidResponseSchema = external_exports.object({
   id: external_exports.string(),
   taskId: external_exports.string(),
-  workerAddress: external_exports.string(),
-  price: external_exports.string(),
+  workerAddress: external_exports.string().nullable(),
+  price: external_exports.string().nullable(),
   createdAt: external_exports.string(),
-  workerAgentId: external_exports.string().nullable().optional()
+  workerAgentId: external_exports.string().nullable().optional(),
+  isMyBid: external_exports.boolean().optional()
 });
 
 // ../../packages/shared/dist/schemas/wallet.schemas.js
@@ -5571,6 +6302,20 @@ var EmailInboundHeadersSchema = external_exports.object({
   "x-email-from": external_exports.string(),
   "x-email-to": external_exports.string().email()
 });
+var BroadcastInputSchema = external_exports.object({
+  subject: external_exports.string().min(1).max(200),
+  body: external_exports.string().min(1).max(5e4),
+  filters: external_exports.object({
+    skills: external_exports.array(external_exports.string()).max(20).optional(),
+    minTasks: external_exports.number().int().min(0).optional(),
+    actorType: external_exports.enum(["agent", "human", "all"]).optional()
+  }).optional()
+});
+var BroadcastResultSchema = external_exports.object({
+  sent: external_exports.number(),
+  failed: external_exports.number(),
+  total: external_exports.number()
+});
 
 // ../../packages/shared/dist/lib/agentName.js
 var MODIFIERS = [
@@ -6595,7 +7340,7 @@ function getDefaultQueryTimeoutMs() {
   }
   return Math.floor(parsed);
 }
-var xmtpCommand = new Command31("xmtp").description("Manage XMTP messaging for this agent");
+var xmtpCommand = new Command41("xmtp").description("Manage XMTP messaging for this agent");
 xmtpCommand.command("init").description("Initialize XMTP client and register installation metadata with backend").action(async () => {
   const keystore = await loadKeystore();
   const client = await createXmtpClient({
@@ -6823,7 +7568,7 @@ xmtpCommand.command("purge").description("Revoke stale XMTP installations that h
 });
 
 // src/commands/daemon.ts
-import { Command as Command32 } from "commander";
+import { Command as Command42 } from "commander";
 function diffTaskStatuses(prev, next) {
   const changes = [];
   for (const [taskId, newStatus] of next) {
@@ -6851,11 +7596,17 @@ function sleepOrAbort(ms, signal) {
   });
 }
 var MAX_SEEN_TASK_IDS = 2e3;
-var daemonCommand = new Command32("daemon").description("Long-running agent daemon: XMTP stream, heartbeats, and task polling").option("--heartbeat-interval <ms>", "Heartbeat interval in milliseconds", "1800000").option("--inbox-interval <ms>", "Inbox poll interval in milliseconds", "15000").option("--task-interval <ms>", "New task poll interval in milliseconds", "60000").option("--task-filters <json>", "JSON filter object for new-task discovery").option("--no-xmtp", "Disable XMTP stream and heartbeat").action(
+var daemonCommand = new Command42("daemon").description("Long-running agent daemon: XMTP stream, heartbeats, and task polling").option("--heartbeat-interval <ms>", "Heartbeat interval in milliseconds", "1800000").option("--inbox-interval <ms>", "Inbox poll interval in milliseconds", "15000").option("--task-interval <ms>", "New task poll interval in milliseconds", "60000").option(
+  "--auction-poll-interval <ms>",
+  "Poll interval for clock-based auction tasks (dutch/reverse_dutch) in milliseconds",
+  "15000"
+).option("--email-poll-interval <ms>", "Email inbox poll interval in milliseconds", "60000").option("--task-filters <json>", "JSON filter object for new-task discovery").option("--no-xmtp", "Disable XMTP stream and heartbeat").action(
   async (opts) => {
     const heartbeatIntervalMs = Number(opts.heartbeatInterval);
     const inboxIntervalMs = Number(opts.inboxInterval);
     const taskIntervalMs = Number(opts.taskInterval);
+    const auctionPollIntervalMs = Number(opts.auctionPollInterval);
+    const emailPollIntervalMs = Number(opts.emailPollInterval);
     if (!Number.isFinite(heartbeatIntervalMs) || heartbeatIntervalMs <= 0) {
       throw new Error("--heartbeat-interval must be a positive number");
     }
@@ -6865,6 +7616,12 @@ var daemonCommand = new Command32("daemon").description("Long-running agent daem
     if (!Number.isFinite(taskIntervalMs) || taskIntervalMs <= 0) {
       throw new Error("--task-interval must be a positive number");
     }
+    if (!Number.isFinite(auctionPollIntervalMs) || auctionPollIntervalMs <= 0) {
+      throw new Error("--auction-poll-interval must be a positive number");
+    }
+    if (!Number.isFinite(emailPollIntervalMs) || emailPollIntervalMs <= 0) {
+      throw new Error("--email-poll-interval must be a positive number");
+    }
     let taskFilters = {};
     if (opts.taskFilters) {
       try {
@@ -7057,7 +7814,99 @@ var daemonCommand = new Command32("daemon").description("Long-running agent daem
             }
           }
         };
-        await Promise.allSettled([inboxPollLoop(), newTaskPollLoop()]);
+        const auctionPollLoop = async () => {
+          while (!stopped) {
+            await sleepOrAbort(auctionPollIntervalMs, abortController.signal);
+            if (stopped) break;
+            try {
+              let cursor;
+              let hasMore = true;
+              while (hasMore) {
+                const params = new URLSearchParams({
+                  mode: "auction",
+                  status: "open",
+                  limit: "50"
+                });
+                if (cursor) params.set("cursor", cursor);
+                const result = await apiGet(`/api/tasks?${params.toString()}`);
+                for (const task of result.tasks) {
+                  if (task.auctionType === "dutch" || task.auctionType === "reverse_dutch") {
+                    printResult({
+                      event: "task.auction_clock",
+                      taskId: task.id,
+                      auctionType: task.auctionType,
+                      currentAuctionPrice: task.currentAuctionPrice ?? null,
+                      bidDeadline: task.bidDeadline ?? null
+                    });
+                  }
+                }
+                cursor = result.nextCursor ?? void 0;
+                hasMore = result.hasMore && cursor !== void 0;
+              }
+            } catch (err) {
+              process.stderr.write(
+                `Auction poll failed: ${err instanceof Error ? err.message : String(err)}
+`
+              );
+            }
+          }
+        };
+        const emailPollLoop = async () => {
+          const PAGE_SIZE = 50;
+          while (!stopped) {
+            await sleepOrAbort(emailPollIntervalMs, abortController.signal);
+            if (stopped) break;
+            try {
+              let hasMore = true;
+              while (hasMore) {
+                const params = new URLSearchParams({
+                  deviceId: keystore.deviceId,
+                  apiToken: keystore.apiToken,
+                  limit: String(PAGE_SIZE),
+                  unread: "true"
+                });
+                const result = await apiGet(
+                  `/api/emails/list?${params.toString()}`
+                );
+                for (const email of result.emails) {
+                  printResult({
+                    event: "email.new",
+                    id: email.id,
+                    fromAddress: email.fromAddress,
+                    subject: email.subject,
+                    bodyText: email.bodyText,
+                    receivedAt: email.receivedAt
+                  });
+                  try {
+                    await apiPost("/api/emails/mark-read", {
+                      deviceId: keystore.deviceId,
+                      apiToken: keystore.apiToken,
+                      id: email.id,
+                      read: true
+                    });
+                  } catch (markErr) {
+                    process.stderr.write(
+                      `Email mark-read failed for ${email.id}: ${markErr instanceof Error ? markErr.message : String(markErr)}
+`
+                    );
+                  }
+                }
+                hasMore = result.emails.length === PAGE_SIZE;
+              }
+            } catch (err) {
+              process.stderr.write(
+                `Email poll failed: ${err instanceof Error ? err.message : String(err)}
+`
+              );
+            }
+          }
+        };
+        await Promise.allSettled([
+          inboxPollLoop(),
+          newTaskPollLoop(),
+          auctionPollLoop(),
+          emailPollLoop()
+        ]);
       };
       await Promise.allSettled([xmtpLoop(), heartbeatLoop(), taskPollLoop()]);
     } finally {
@@ -7068,11 +7917,11 @@ var daemonCommand = new Command32("daemon").description("Long-running agent daem
 );
 
 // src/commands/email/index.ts
-import { Command as Command41 } from "commander";
+import { Command as Command51 } from "commander";
 
 // src/commands/email/register.ts
-import { Command as Command33 } from "commander";
-var registerCommand = new Command33("register").description("Register an email address for this agent").requiredOption("--username <name>", "Desired username (e.g. myagent)").action(async (opts) => {
+import { Command as Command43 } from "commander";
+var registerCommand = new Command43("register").description("Register an email address for this agent").requiredOption("--username <name>", "Desired username (e.g. myagent)").action(async (opts) => {
   const check = await apiGet(
     `/api/emails/check-username?username=${encodeURIComponent(opts.username)}`
   );
@@ -7089,8 +7938,8 @@ var registerCommand = new Command33("register").description("Register an email a
 });
 
 // src/commands/email/inbox.ts
-import { Command as Command34 } from "commander";
-var inboxCommand2 = new Command34("inbox").description("List emails in your inbox").option("--limit <n>", "Number of emails to return", "20").option("--unread", "Show only unread emails").action(async (opts) => {
+import { Command as Command44 } from "commander";
+var inboxCommand2 = new Command44("inbox").description("List emails in your inbox").option("--limit <n>", "Number of emails to return", "20").option("--unread", "Show only unread emails").action(async (opts) => {
   const keystore = await loadKeystore();
   const params = new URLSearchParams({
     deviceId: keystore.deviceId,
@@ -7105,8 +7954,8 @@ var inboxCommand2 = new Command34("inbox").description("List emails in your inbo
 });
 
 // src/commands/email/read.ts
-import { Command as Command35 } from "commander";
-var readCommand = new Command35("read").description("Read an email by ID (marks it as read)").argument("<id>", "Email ID").action(async (id) => {
+import { Command as Command45 } from "commander";
+var readCommand = new Command45("read").description("Read an email by ID (marks it as read)").argument("<id>", "Email ID").action(async (id) => {
   const keystore = await loadKeystore();
   const params = new URLSearchParams({
     deviceId: keystore.deviceId,
@@ -7118,8 +7967,8 @@ var readCommand = new Command35("read").description("Read an email by ID (marks
 });
 
 // src/commands/email/send.ts
-import { Command as Command36 } from "commander";
-var sendCommand = new Command36("send").description("Send an email").requiredOption("--to <address>", "Recipient email address").requiredOption("--subject <subject>", "Email subject").requiredOption("--body <text>", "Email body text").action(async (opts) => {
+import { Command as Command46 } from "commander";
+var sendCommand = new Command46("send").description("Send an email").requiredOption("--to <address>", "Recipient email address").requiredOption("--subject <subject>", "Email subject").requiredOption("--body <text>", "Email body text").action(async (opts) => {
   const keystore = await loadKeystore();
   const result = await apiPost("/api/emails/send", {
     deviceId: keystore.deviceId,
@@ -7132,8 +7981,8 @@ var sendCommand = new Command36("send").description("Send an email").requiredOpt
 });
 
 // src/commands/email/reply.ts
-import { Command as Command37 } from "commander";
-var replyCommand = new Command37("reply").description("Reply to an email").argument("<id>", "Email ID to reply to").requiredOption("--body <text>", "Reply body text").action(async (id, opts) => {
+import { Command as Command47 } from "commander";
+var replyCommand = new Command47("reply").description("Reply to an email").argument("<id>", "Email ID to reply to").requiredOption("--body <text>", "Reply body text").action(async (id, opts) => {
   const keystore = await loadKeystore();
   const params = new URLSearchParams({
     deviceId: keystore.deviceId,
@@ -7155,8 +8004,8 @@ var replyCommand = new Command37("reply").description("Reply to an email").argum
 });
 
 // src/commands/email/delete.ts
-import { Command as Command38 } from "commander";
-var deleteCommand = new Command38("delete").description("Delete an email by ID").argument("<id>", "Email ID").action(async (id) => {
+import { Command as Command48 } from "commander";
+var deleteCommand = new Command48("delete").description("Delete an email by ID").argument("<id>", "Email ID").action(async (id) => {
   const keystore = await loadKeystore();
   const result = await apiPost("/api/emails/delete", {
     deviceId: keystore.deviceId,
@@ -7167,15 +8016,15 @@ var deleteCommand = new Command38("delete").description("Delete an email by ID")
 });
 
 // src/commands/email/address.ts
-import { Command as Command39 } from "commander";
-var addressCommand2 = new Command39("address").description("Show your registered email address").action(async () => {
+import { Command as Command49 } from "commander";
+var addressCommand2 = new Command49("address").description("Show your registered email address").action(async () => {
   const keystore = await loadKeystore();
   const result = await apiGet(`/api/agents/stats?address=${keystore.walletAddress}`);
   printResult({ emailAddress: result.emailAddress ?? null });
 });
 
 // src/commands/email/mark-read.ts
-import { Command as Command40 } from "commander";
+import { Command as Command50 } from "commander";
 async function setReadStatus(id, read) {
   const keystore = await loadKeystore();
   const result = await apiPost("/api/emails/mark-read", {
@@ -7186,12 +8035,12 @@ async function setReadStatus(id, read) {
   });
   printResult({ id: result.id, isRead: result.isRead });
 }
-var markReadCommand = new Command40("mark-read").description("Mark an email as read or unread").argument("<id>", "Email ID").option("--unread", "Mark as unread instead of read").action(async (id, opts) => {
+var markReadCommand = new Command50("mark-read").description("Mark an email as read or unread").argument("<id>", "Email ID").option("--unread", "Mark as unread instead of read").action(async (id, opts) => {
   await setReadStatus(id, !opts.unread);
 });
 
 // src/commands/email/index.ts
-var emailCommand = new Command41("email").description("Email management commands");
+var emailCommand = new Command51("email").description("Email management commands");
 emailCommand.addCommand(registerCommand);
 emailCommand.addCommand(inboxCommand2);
 emailCommand.addCommand(readCommand);
@@ -7204,7 +8053,7 @@ emailCommand.addCommand(markReadCommand);
 // src/index.ts
 var require2 = createRequire(import.meta.url);
 var { version } = require2("../package.json");
-var program = new Command42();
+var program = new Command52();
 program.name("taskmarket").description("Taskmarket CLI for AI agents").version(version);
 program.addCommand(initCommand);
 program.addCommand(walletCommand);