@lucid-agents/taskmarket 1.17.2 → 1.18.0

package/dist/index.js

@@ -1,5 +1,20 @@
 #!/usr/bin/env node
 import { createRequire as __tmCreateRequire } from 'node:module'; import { fileURLToPath as __tmFileURLToPath } from 'node:url'; import { dirname as __tmDirname } from 'node:path'; const require = __tmCreateRequire(import.meta.url); const __tmFilename = __tmFileURLToPath(import.meta.url); const __tmDirnameValue = __tmDirname(__tmFilename);
+import {
+  TaskOperationError,
+  claimTask,
+  cliTaskReadContext,
+  cliTaskWriteContext,
+  getTask,
+  getTaskTerms,
+  listTaskSubmissions,
+  listTasks,
+  listWorkerSubmissions,
+  saveTaskAccessGrant,
+  signReadAuth,
+  submitTaskFiles,
+  taskAccessGrantHeaders
+} from "./chunk-JJUF3KZY.js";
 import {
   ComputeCreditError,
   applyComputeCreditSetup,
@@ -20,101 +35,199 @@ import {
   reconcileX402PaymentById,
   refusedPaidWrite,
   releasePendingComputePurchase,
-  resolvePendingComputePurchases,
-  x402FeePost
-} from "./chunk-52Q2DCZN.js";
+  resolvePendingComputePurchases
+} from "./chunk-W7CXEYST.js";
+import {
+  MPP_TEMPO_DEFAULT_VALIDITY_SECONDS,
+  X402PayError,
+  X402_POLICY_JSON_SCHEMA,
+  addX402PolicyRule,
+  createWalletAccountFromKeystore,
+  fetchDeviceKey,
+  getWalletAddress,
+  getX402JournalPath,
+  getX402Payment,
+  getX402PolicyPath,
+  initializeX402Policy,
+  listX402Payments,
+  loadX402Policy,
+  removeX402PolicyRule,
+  resolveX402PaymentManually,
+  setX402PolicyRuleEnabled,
+  signMessage,
+  signSponsoredTempoTransfer,
+  signTaskmarketFeePayment,
+  signTypedData
+} from "./chunk-S4A6V3J3.js";
 import {
   AgentMessageEnvelopeSchema,
   ApiError,
+  BUG_REPORT_SEVERITIES,
+  BUG_REPORT_STATUSES,
+  DEFAULT_TERMS_BOUNDS,
+  IntentStatusResponseSchema,
   LegalAcceptanceResponseSchema,
   LegalBundleSchema,
   LegalChallengeResponseSchema,
   LegalStatusResponseSchema,
-  MPP_TEMPO_DEFAULT_VALIDITY_SECONDS,
   NETWORK_NAMES,
+  PenaltyTo,
   READ_AUTH_ADDRESS_HEADER,
   READ_AUTH_SIGNATURE_HEADER,
+  REDACTED,
+  RejectOutcome,
   SponsoredTaskRewardStateSchema,
   SponsoredTaskWorkerRewardClaimStatusSchema,
-  TASK_ACCESS_GRANT_HEADER,
-  X402PayError,
-  X402_POLICY_JSON_SCHEMA,
-  addX402PolicyRule,
+  SubmissionReviewAssessmentInputSchema,
+  SubmissionReviewAssessmentOutputSchema,
+  SubmissionReviewCorrectionSchema,
+  SubmissionReviewHistoryInputSchema,
+  SubmissionReviewHistoryOutputSchema,
+  SubmissionReviewJobStatusSchema,
+  SubmissionReviewLookupInputSchema,
+  SubmissionReviewPreviewInputSchema,
+  SubmissionReviewPreviewOutputSchema,
+  SubmissionReviewProfileOutputSchema,
+  SubmissionReviewResultStateSchema,
+  SubmissionReviewResultsInputSchema,
+  SubmissionReviewResultsOutputSchema,
+  SubmissionReviewRunInputSchema,
+  SubmissionReviewRunSummarySchema,
+  SubmissionReviewStartPayloadSchema,
+  SubmissionReviewTaskInputSchema,
+  SubmitBugReportInputSchema,
+  TaskTermsError,
+  TermsPresetName,
+  WALLET_BRIDGE_ORIGIN_CHAIN_ID,
+  WALLET_BRIDGE_TEMPO_CHAIN_ID,
   apiDelete,
+  apiErrorEnvelopeOf,
   apiGet,
   apiOrigin,
   apiPost,
+  apiReadPost,
   apiUrl,
-  buildClaimMessage,
   buildDeviceRegisterMessage,
   buildForfeitMessage,
   buildLegalReceiptHeaders,
+  buildPitchMessage,
+  buildProofMessage,
   buildReadAuthMessage,
   buildRevealAccountRecoveryCodeMessage,
   buildSelectWorkerMessage,
   buildSetWithdrawalAddressMessage,
+  buildSettlementActionMessage,
   buildSponsoredTaskVaultReviewRequestMessage,
-  buildSubmitMessage,
+  buildSubmissionReviewActionMessage,
   buildWalletLegalAcceptanceMessage,
   buildWithdrawDreamsMessage,
   chainInfoFor,
+  claimStakeToPost,
   clientValidityWindowSeconds,
-  createWalletAccountFromKeystore,
   decryptPrivateKey,
   dreamsToUsd,
   encryptPrivateKey,
-  fetchDeviceKey,
   formatDreams,
+  formatPaymentAmount,
   formatUsdcBaseUnits,
   generateKeypair,
   getTaskmarketHome,
-  getWalletAddress,
-  getX402JournalPath,
-  getX402Payment,
-  getX402PolicyPath,
   idempotencyKeyForError,
-  initializeX402Policy,
   isInFlightApiError,
   isPendingApiError,
+  isRecordingPendingResponse,
+  isTerminalWalletBridgeStatus,
   keystoreExists,
-  listX402Payments,
   loadKeystore,
-  loadX402Policy,
   networkToStamp,
   paymentProtocolOf,
   paymentTokenSymbol,
   readFailureBody,
   readKeystoreNetwork,
-  removeX402PolicyRule,
+  redactSecrets,
   resolveIdempotencyKey,
   resolveNetwork,
-  resolveX402PaymentManually,
+  resolveTaskTerms,
   saveKeystore,
   selectedNetwork,
   setSelectedNetwork,
-  setX402PolicyRuleEnabled,
-  signMessage,
-  signSponsoredTempoTransfer,
-  signTaskmarketFeePayment,
-  signTypedData,
+  settlementActionExpiresAt,
+  settlementActionRequiresExpiry,
   taskmarketChain,
   usdcToBaseUnits,
   withErrorContext,
   withIdempotentWrite
-} from "./chunk-FRV3ZHUR.js";
+} from "./chunk-75LS6XS6.js";
 import {
   channelLines
-} from "./chunk-73RXOYME.js";
+} from "./chunk-EB6OJBF5.js";
 import "./chunk-S7SJMJ2I.js";
 
 // src/index.ts
-import { Command as Command93 } from "commander";
+import { Command as Command103 } from "commander";
 import { createRequire } from "module";
 
 // src/commands/init.ts
 import { Command as Command2 } from "commander";
 import { privateKeyToAccount } from "viem/accounts";
 
+// src/lib/last-error.ts
+import fs from "fs";
+import path from "path";
+var REPORT_BUG_HINT = "taskmarket bug submit --include-last-error";
+var SECRET_FLAG = /^--?(?:[\w-]*(?:key|secret|token|password|passphrase|mnemonic|seed)[\w-]*)$/i;
+var cliVersion = "unknown";
+function setLastErrorCliVersion(version2) {
+  cliVersion = version2;
+}
+function lastErrorPath() {
+  return path.join(getTaskmarketHome(), "last-error.json");
+}
+function redactArgv(argv) {
+  const out = [];
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    const eq = arg.indexOf("=");
+    if (arg.startsWith("-") && eq > 0 && SECRET_FLAG.test(arg.slice(0, eq))) {
+      out.push(`${arg.slice(0, eq)}=${REDACTED}`);
+    } else if (SECRET_FLAG.test(arg) && i + 1 < argv.length) {
+      out.push(arg, REDACTED);
+      i++;
+    } else {
+      out.push(redactSecrets(arg));
+    }
+  }
+  return out;
+}
+function currentArgs() {
+  return process.argv.slice(2);
+}
+function recordLastError(error, argv = currentArgs()) {
+  if (argv[0] === "bug") return false;
+  const record = {
+    command: ["taskmarket", ...redactArgv(argv)].join(" "),
+    message: redactSecrets(error.message),
+    ...typeof error.code === "string" ? { code: error.code } : {},
+    ...error.status !== void 0 ? { status: error.status } : {},
+    at: (/* @__PURE__ */ new Date()).toISOString(),
+    cliVersion
+  };
+  try {
+    fs.mkdirSync(getTaskmarketHome(), { recursive: true, mode: 448 });
+    fs.writeFileSync(lastErrorPath(), JSON.stringify(record, null, 2) + "\n", { mode: 384 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function readLastError() {
+  try {
+    return JSON.parse(fs.readFileSync(lastErrorPath(), "utf8"));
+  } catch {
+    return null;
+  }
+}
+
 // src/lib/output.ts
 function printResult(data, options) {
   const idempotencyKey = options?.idempotencyKey;
@@ -142,6 +255,13 @@ function renderFailure(error, options) {
   const x402PayError = error instanceof X402PayError ? error : void 0;
   const idempotencyKey = options?.idempotencyKey ?? apiError?.idempotencyKey ?? idempotencyKeyForError(error);
   const envelope = apiError?.envelope;
+  const status = apiError?.status ?? x402PayError?.status;
+  const errorCode = error?.code;
+  const recorded = recordLastError({
+    message,
+    code: envelope?.reason ?? errorCode,
+    status
+  });
   process.stderr.write(
     JSON.stringify({
       ok: false,
@@ -152,7 +272,8 @@ function renderFailure(error, options) {
       ...x402PayError?.pending !== void 0 ? { pending: x402PayError.pending } : {},
       ...x402PayError?.payment !== void 0 ? { payment: x402PayError.payment } : {},
       ...x402PayError !== void 0 ? x402FailureFields(x402PayError) : {},
-      ...options?.details ?? {}
+      ...options?.details ?? {},
+      ...recorded ? { reportBug: REPORT_BUG_HINT } : {}
     }) + "\n"
   );
   process.exitCode = 1;
@@ -171,7 +292,9 @@ async function pollAgentId(address, maxWaitMs = 6e4) {
   while (Date.now() < deadline) {
     await new Promise((r) => setTimeout(r, interval));
     try {
-      const res = await fetch(`${apiUrl()}/api/identity/status?address=${address}`);
+      const res = await fetch(
+        `${apiUrl()}/api/identity/status?address=${address}&chainId=${selectedNetwork().chainId}`
+      );
       if (res.ok) {
         const data = await res.json();
         if (data.agentId) return data.agentId;
@@ -591,7 +714,17 @@ var addressCommand = new Command3("address").description("Print the wallet addre
 import { Command as Command4 } from "commander";
 
 // src/lib/x402.ts
+var FACILITATOR_RETRIES = 2;
+var MAX_RETRY_AFTER_SECONDS = 60;
+var DEFAULT_RETRY_AFTER_SECONDS = 30;
+function retryAfterMs(res) {
+  const header = res.headers?.get?.("retry-after");
+  const seconds = header ? Number(header) : NaN;
+  const wait = Number.isFinite(seconds) && seconds >= 0 ? seconds : DEFAULT_RETRY_AFTER_SECONDS;
+  return Math.min(wait, MAX_RETRY_AFTER_SECONDS) * 1e3;
+}
 async function x402Post(path3, body, options) {
+  const sleep4 = options?.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
   if (paymentProtocolOf(selectedNetwork().chainId) === "mpp")
     return mppPost(path3, body, options);
   const keystore = await loadKeystore();
@@ -622,16 +755,21 @@ async function x402Post(path3, body, options) {
       from: keystore.walletAddress,
       signTypedData: (typedData) => signTypedData(typedData, keystore)
     });
-    const r2 = await fetch(request.url, {
-      method: "POST",
-      redirect: "error",
-      headers: { ...request.headers, "PAYMENT-SIGNATURE": header },
-      body: request.body
-    });
-    if (!r2.ok) {
-      throw failedAfterPayment(path3, r2.status, await readFailureBody(r2), idempotencyKey);
+    for (let attempt = 0; ; attempt++) {
+      const r2 = await fetch(request.url, {
+        method: "POST",
+        redirect: "error",
+        headers: { ...request.headers, "PAYMENT-SIGNATURE": header },
+        body: request.body
+      });
+      if (r2.ok) return { data: await r2.json(), idempotencyKey };
+      const read = await readFailureBody(r2);
+      if (r2.status === 503 && apiErrorEnvelopeOf(read.body)?.reason === "facilitator_unavailable" && attempt < FACILITATOR_RETRIES) {
+        await sleep4(retryAfterMs(r2));
+        continue;
+      }
+      throw failedAfterPayment(path3, r2.status, read, idempotencyKey);
     }
-    return { data: await r2.json(), idempotencyKey };
   });
 }
 
@@ -643,7 +781,9 @@ identityCommand.command("register").description("Register ERC-8004 agent identit
 });
 identityCommand.command("status").description("Check identity registration status").action(async () => {
   const keystore = await loadKeystore();
-  const result = await apiGet(`/api/identity/status?address=${keystore.walletAddress}`);
+  const result = await apiGet(
+    `/api/identity/status?address=${keystore.walletAddress}&chainId=${selectedNetwork().chainId}`
+  );
   printResult({ registered: result.registered, agentId: result.agentId });
 });
 
@@ -698,15 +838,550 @@ var statsCommand = new Command5("stats").description("View agent statistics").op
 });
 
 // src/commands/task/index.ts
-import { Command as Command41 } from "commander";
+import { Command as Command45 } from "commander";
+
+// src/commands/task/review.ts
+import { readFile, stat } from "fs/promises";
+import { Command as Command6, Option } from "commander";
+import { z as z2 } from "zod";
+
+// src/lib/submission-reviews.ts
+import { z } from "zod";
+var controlOutput = z.object({
+  runId: z.string().uuid(),
+  status: z.union([SubmissionReviewJobStatusSchema, z.literal("deleted")])
+});
+var correctionOutput = z.object({
+  correctionId: z.string().uuid(),
+  createdAt: z.string().datetime()
+});
+var query = (values) => {
+  const params = new URLSearchParams();
+  for (const [key, value] of Object.entries(values))
+    if (value !== void 0) params.set(key, String(value));
+  return params.size ? `?${params}` : "";
+};
+var taskPath = (taskId) => `/api/tasks/${encodeURIComponent(taskId)}`;
+var runPath = (runId) => `/api/submission-reviews/${encodeURIComponent(runId)}`;
+function createSubmissionReviewClient(options) {
+  const now = options.now ?? Date.now;
+  const sleep4 = options.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  let headersPromise;
+  const headers = () => headersPromise ??= (async () => {
+    const signer = await options.signer();
+    return {
+      [READ_AUTH_ADDRESS_HEADER]: signer.address,
+      [READ_AUTH_SIGNATURE_HEADER]: await signer.signMessage(
+        buildReadAuthMessage(signer.address)
+      )
+    };
+  })();
+  async function get(path3, schema) {
+    return schema.parse(await options.transport.get(path3, await headers()));
+  }
+  async function write(action, payload, chainId, path3, schema, key) {
+    const idempotencyKey = z.string().uuid().parse(resolveIdempotencyKey(key)).toLowerCase();
+    return withIdempotentWrite(idempotencyKey, async () => {
+      const signer = await options.signer();
+      const expiresAt = Math.floor(now() / 1e3) + 240;
+      const signature = await signer.signMessage(
+        buildSubmissionReviewActionMessage({
+          action,
+          payload,
+          chainId,
+          requester: signer.address,
+          idempotencyKey,
+          expiresAt
+        })
+      );
+      const body = {
+        ...payload,
+        chainId,
+        requesterAddress: signer.address,
+        idempotencyKey,
+        expiresAt,
+        signature,
+        ...["pause", "cancel", "delete"].includes(action) ? { action } : {}
+      };
+      const result = await options.transport.post(path3, body, idempotencyKey);
+      if (result.idempotencyKey !== idempotencyKey)
+        throw new Error(
+          "Review response has a different request key; recover the original request before retrying."
+        );
+      return { data: schema.parse(result.data), idempotencyKey };
+    });
+  }
+  const client = {
+    async profile(input) {
+      const { taskId, ...params } = SubmissionReviewTaskInputSchema.parse(input);
+      return get(
+        `${taskPath(taskId)}/submission-review-profile${query(params)}`,
+        SubmissionReviewProfileOutputSchema
+      );
+    },
+    async preview(input) {
+      const parsed = SubmissionReviewPreviewInputSchema.parse(input);
+      if (parsed.scope !== "selected" && parsed.submissionIds)
+        throw new Error("Submission IDs require selected scope.");
+      if (parsed.scope === "selected" && !parsed.submissionIds?.length)
+        throw new Error("Selected scope requires submission IDs.");
+      const { taskId, ...body } = parsed;
+      return SubmissionReviewPreviewOutputSchema.parse(
+        await options.transport.preview(
+          `${taskPath(taskId)}/submission-reviews/preview`,
+          body,
+          await headers()
+        )
+      );
+    },
+    async start(input, expectedTaskId, key) {
+      const preview = SubmissionReviewPreviewOutputSchema.parse(input);
+      SubmissionReviewRunInputSchema.shape.chainId.parse(preview.chainId);
+      if (preview.taskId !== expectedTaskId)
+        throw new Error("Preview belongs to a different task.");
+      if (!preview.canStart || !preview.profile.profileFingerprint)
+        throw new Error("This preview cannot start a review. Obtain a fresh eligible preview.");
+      const payload = SubmissionReviewStartPayloadSchema.parse({
+        taskId: preview.taskId,
+        sourceFingerprint: preview.sourceFingerprint,
+        profileFingerprint: preview.profile.profileFingerprint,
+        submissionIds: preview.submissionIds
+      });
+      return write(
+        "start",
+        payload,
+        preview.chainId,
+        `${taskPath(preview.taskId)}/submission-reviews`,
+        SubmissionReviewRunSummarySchema,
+        key
+      );
+    },
+    async status(input) {
+      const { runId, ...params } = SubmissionReviewRunInputSchema.parse(input);
+      return get(`${runPath(runId)}${query(params)}`, SubmissionReviewRunSummarySchema);
+    },
+    async lookup(input) {
+      const { idempotencyKey, ...params } = SubmissionReviewLookupInputSchema.parse(input);
+      return get(
+        `/api/submission-review-requests/${idempotencyKey}${query(params)}`,
+        SubmissionReviewRunSummarySchema
+      );
+    },
+    async control(action, input, key) {
+      z.enum(["pause", "resume", "cancel", "delete"]).parse(action);
+      const { runId, chainId } = SubmissionReviewRunInputSchema.parse(input);
+      return write(
+        action,
+        { runId },
+        chainId,
+        `${runPath(runId)}/${action === "resume" ? "resume" : "control"}`,
+        controlOutput,
+        key
+      );
+    },
+    async results(input) {
+      const { taskId, ...params } = SubmissionReviewResultsInputSchema.parse(input);
+      return get(
+        `${taskPath(taskId)}/submission-review-results${query(params)}`,
+        SubmissionReviewResultsOutputSchema
+      );
+    },
+    async allResults(input) {
+      if (input.cursor) throw new Error("Do not combine --all and --cursor.");
+      for (let attempt = 0; attempt < 2; attempt++) {
+        try {
+          const first = await client.results({ ...input, limit: 100 });
+          const rows = [...first.rows];
+          let cursor = first.nextCursor;
+          const seen = /* @__PURE__ */ new Set();
+          while (cursor) {
+            if (seen.has(cursor)) throw new Error("Review pagination did not advance.");
+            seen.add(cursor);
+            const page = await client.results({ ...input, limit: 100, cursor });
+            if (page.viewFingerprint !== first.viewFingerprint)
+              throw new ApiError(409, "Review changed during pagination.");
+            rows.push(...page.rows);
+            cursor = page.nextCursor;
+          }
+          return { ...first, rows, nextCursor: null };
+        } catch (error) {
+          if (attempt === 0 && error instanceof ApiError && error.status === 409) continue;
+          throw error;
+        }
+      }
+      throw new Error("Review changed. Read the results again.");
+    },
+    async history(input) {
+      const { taskId, ...params } = SubmissionReviewHistoryInputSchema.parse(input);
+      return get(
+        `${taskPath(taskId)}/submission-reviews${query(params)}`,
+        SubmissionReviewHistoryOutputSchema
+      );
+    },
+    async assessment(input) {
+      const { runId, submissionId, ...params } = SubmissionReviewAssessmentInputSchema.parse(input);
+      return get(
+        `${runPath(runId)}/assessments/${encodeURIComponent(submissionId)}${query(params)}`,
+        SubmissionReviewAssessmentOutputSchema
+      );
+    },
+    async correct(input, key) {
+      const { runId, chainId } = SubmissionReviewRunInputSchema.parse({
+        runId: input.runId,
+        chainId: input.chainId
+      });
+      const payload = {
+        runId,
+        assessmentId: z.string().uuid().parse(input.assessmentId),
+        correction: SubmissionReviewCorrectionSchema.parse(input.correction)
+      };
+      return write(
+        "correct",
+        payload,
+        chainId,
+        `${runPath(runId)}/corrections`,
+        correctionOutput,
+        key
+      );
+    },
+    async *watch(input, settings = {}) {
+      const { intervalSeconds, timeoutSeconds } = z.object({
+        intervalSeconds: z.number().int().min(1).max(60).default(5),
+        timeoutSeconds: z.number().int().min(1).max(86400).default(300)
+      }).parse(settings);
+      const deadline = now() + timeoutSeconds * 1e3;
+      while (true) {
+        const status = await client.status(input);
+        yield status;
+        if (!["queued", "running"].includes(status.status) || now() >= deadline) return;
+        await sleep4(Math.min(intervalSeconds * 1e3, Math.max(0, deadline - now())));
+      }
+    }
+  };
+  return client;
+}
+function cliSubmissionReviewClient() {
+  return createSubmissionReviewClient({
+    signer: async () => {
+      const keystore = await loadKeystore();
+      return {
+        address: keystore.walletAddress,
+        signMessage: (message) => signMessage(message, keystore)
+      };
+    },
+    transport: {
+      get: (path3, headers) => apiGet(path3, { headers }),
+      preview: (path3, body, headers) => apiReadPost(path3, body, { headers }),
+      post: (path3, body, idempotencyKey) => apiPost(path3, body, { idempotencyKey })
+    }
+  });
+}
+
+// src/commands/task/review.ts
+var integer = (value) => z2.coerce.number().int().positive().safe().parse(value);
+var collect = (value, values) => [...values, value];
+var taskCommand = (name, description) => new Command6(name).description(description).argument("<taskId>", "Task ID").option("--chain-id <id>", "Require this task chain", integer);
+var runCommand = (name, description) => new Command6(name).description(description).argument("<runId>", "Private review run ID").requiredOption("--chain-id <id>", "Chain recorded on the review run", integer);
+function createReviewCommand() {
+  const group = new Command6("review").description(
+    "Requester-private advisory brief review and experimental taste scoring; never awards or rejects work"
+  );
+  group.addCommand(
+    taskCommand(
+      "profile",
+      "Show review availability, supported media and evaluator version"
+    ).action(async (taskId, options) => {
+      printResult(await cliSubmissionReviewClient().profile({ taskId, chainId: options.chainId }));
+    })
+  );
+  group.addCommand(
+    taskCommand("preview", "Preview the exact brief and submission set without running inference").addOption(
+      new Option("--scope <scope>", "latest versions, remaining versions, or selected IDs").choices(["latest", "remaining", "selected"]).default("latest")
+    ).option(
+      "--submission-id <id>",
+      "Submission ID for selected scope; repeat for multiple submissions",
+      collect,
+      []
+    ).action(
+      async (taskId, options) => {
+        printResult(
+          await cliSubmissionReviewClient().preview({
+            taskId,
+            chainId: options.chainId,
+            scope: options.scope,
+            ...options.submissionId.length ? { submissionIds: options.submissionId } : {}
+          })
+        );
+      }
+    )
+  );
+  group.addCommand(
+    new Command6("start").description(
+      "Sign and start the exact saved preview; obtain a fresh preview if sources changed"
+    ).argument("<taskId>", "Task ID").requiredOption("--preview-file <path>", "JSON output from task review preview").action(async (taskId, options) => {
+      const info = await stat(options.previewFile);
+      if (!info.isFile() || info.size > 1048576)
+        throw new Error("Review preview must be a JSON file of at most 1 MiB.");
+      const input = JSON.parse(await readFile(options.previewFile, "utf8"));
+      const preview = input && typeof input === "object" && "ok" in input && input.ok === true && "data" in input ? input.data : input;
+      const result = await cliSubmissionReviewClient().start(preview, taskId);
+      printResult(result.data, { idempotencyKey: result.idempotencyKey });
+    })
+  );
+  group.addCommand(
+    runCommand("status", "Read saved progress; watching never starts or resumes inference").option("--watch", "Emit one JSON result per poll until stopped, completed, or timeout").option("--interval <seconds>", "Seconds between status reads (1\u201360)", integer, 5).option(
+      "--timeout <seconds>",
+      "Maximum polling duration (1\u201386400); the run keeps its current state",
+      integer,
+      300
+    ).action(
+      async (runId, options) => {
+        const client = cliSubmissionReviewClient();
+        const input = { runId, chainId: options.chainId };
+        if (!options.watch) {
+          printResult(await client.status(input));
+          return;
+        }
+        for await (const status of client.watch(input, {
+          intervalSeconds: options.interval,
+          timeoutSeconds: options.timeout
+        }))
+          printResult(status);
+      }
+    )
+  );
+  group.addCommand(
+    new Command6("lookup").description("Recover an accepted run by request key without sending the write again").argument("<requestKey>", "Idempotency key from the start result or error").requiredOption("--chain-id <id>", "Chain from the saved preview", integer).action(async (idempotencyKey, options) => {
+      printResult(
+        await cliSubmissionReviewClient().lookup({ idempotencyKey, chainId: options.chainId })
+      );
+    })
+  );
+  for (const [action, description] of [
+    ["pause", "Pause before the next provider call; already-dispatched calls may finish"],
+    ["resume", "Explicitly resume an eligible paused run"],
+    ["cancel", "Cancel remaining work and retain completed assessments"],
+    ["delete", "Delete this private report, evidence and corrections; billing records remain"]
+  ]) {
+    const command = runCommand(action, description);
+    if (action === "delete")
+      command.requiredOption("--confirm", "Confirm irreversible report deletion");
+    command.action(async (runId, options) => {
+      const result = await cliSubmissionReviewClient().control(action, {
+        runId,
+        chainId: options.chainId
+      });
+      printResult(result.data, { idempotencyKey: result.idempotencyKey });
+    });
+    group.addCommand(command);
+  }
+  group.addCommand(
+    taskCommand(
+      "results",
+      "Filter and rank saved results before pagination; new versions never inherit older scores"
+    ).option("--run-id <id>", "Inspect the exact frozen cohort of a historical run").addOption(
+      new Option("--compliance <state>", "Brief compliance").choices([
+        "supported",
+        "pending",
+        "unmet"
+      ])
+    ).addOption(
+      new Option("--quality-band <band>", "Experimental taste band").choices([
+        "strong",
+        "mixed",
+        "weak"
+      ])
+    ).addOption(
+      new Option("--state <state>", "Processing or freshness state").choices(
+        SubmissionReviewResultStateSchema.options
+      )
+    ).option(
+      "--shortlist",
+      "Only shortlist suggestions; pending verification can still be present"
+    ).addOption(
+      new Option("--sort <sort>", "Saved ranking or submission time").choices(["rank", "newest"]).default("rank")
+    ).option("--limit <count>", "Rows per page (1\u2013100)", integer, 24).option("--cursor <cursor>", "Cursor returned by the same result view").option("--all", "Read all pages as one consistent result; no inference").action(
+      async (taskId, options) => {
+        const { all, ...filters } = options;
+        const client = cliSubmissionReviewClient();
+        const input = { taskId, ...filters };
+        printResult(all ? await client.allResults(input) : await client.results(input));
+      }
+    )
+  );
+  group.addCommand(
+    taskCommand("history", "List saved review runs for this task").option("--limit <count>", "Runs per page (1\u2013100)", integer, 20).option("--cursor <runId>", "Cursor returned by the preceding history page").action(async (taskId, options) => {
+      printResult(await cliSubmissionReviewClient().history({ taskId, ...options }));
+    })
+  );
+  group.addCommand(
+    runCommand(
+      "assessment",
+      "Read the frozen brief, evidence, original assessment and requester corrections"
+    ).argument("<submissionId>", "Exact submission version ID").action(async (runId, submissionId, options) => {
+      printResult(
+        await cliSubmissionReviewClient().assessment({
+          runId,
+          submissionId,
+          chainId: options.chainId
+        })
+      );
+    })
+  );
+  group.addCommand(
+    runCommand(
+      "correct",
+      "Append a signed requester correction; preserve the original model finding"
+    ).argument("<assessmentId>", "Assessment ID from results or assessment output").requiredOption("--requirement-id <id>", "Checklist requirement to correct").addOption(
+      new Option("--status <status>", "Corrected requirement status").choices(["supported", "unmet", "pending", "not_applicable"]).makeOptionMandatory()
+    ).requiredOption("--reason <text>", "Reason for the correction").option("--evidence-id <id>", "Existing evidence ID; repeat as needed", collect, []).action(
+      async (runId, assessmentId, options) => {
+        const result = await cliSubmissionReviewClient().correct({
+          runId,
+          assessmentId,
+          chainId: options.chainId,
+          correction: {
+            requirementId: options.requirementId,
+            status: options.status,
+            reason: options.reason.trim(),
+            evidenceIds: options.evidenceId
+          }
+        });
+        printResult(result.data, { idempotencyKey: result.idempotencyKey });
+      }
+    )
+  );
+  return group;
+}
+var reviewCmd = createReviewCommand();
 
 // src/commands/task/create.ts
-import { Command as Command6 } from "commander";
+import { Command as Command7 } from "commander";
 import { parseUnits } from "viem";
+
+// src/lib/settlement-terms.ts
+var TERM_FLAGS = {
+  stakeRequired: "--stake-required",
+  stakeBps: "--stake-bps",
+  penaltyTo: "--penalty-to",
+  reviewWindowSecs: "--review-window",
+  decisionWindowSecs: "--decision-window",
+  reopenExtensionSecs: "--reopen-extension",
+  releaseAllowed: "--release",
+  releaseGraceBps: "--release-grace-bps",
+  rejectOutcome: "--reject-outcome",
+  rejectFeeBps: "--reject-fee-bps",
+  maxRevisions: "--max-revisions",
+  resolutionWindowSecs: "--resolution-window"
+};
+function hoursToSecs(flag, value) {
+  const hours = Number(value);
+  if (value.trim() === "" || !Number.isFinite(hours) || hours <= 0) {
+    return { error: `${flag} must be a positive number of hours` };
+  }
+  return Math.round(hours * 3600);
+}
+function integer2(flag, value, max) {
+  if (!/^\d+$/.test(value.trim()) || Number(value) > max) {
+    return { error: `${flag} must be an integer between 0 and ${max}` };
+  }
+  return Number(value);
+}
+function parseTermsFlags(opts) {
+  const terms = {};
+  let termsPreset;
+  if (opts.termsPreset !== void 0) {
+    const parsed = TermsPresetName.safeParse(opts.termsPreset);
+    if (!parsed.success) {
+      return { error: `--terms-preset must be one of: ${TermsPresetName.options.join(", ")}` };
+    }
+    termsPreset = parsed.data;
+  }
+  if (opts.stakeRequired !== void 0) terms.stakeRequired = opts.stakeRequired;
+  if (opts.stakeBps !== void 0) {
+    const bps = integer2("--stake-bps", opts.stakeBps, 1e4);
+    if (typeof bps !== "number") return bps;
+    terms.stakeBps = bps;
+    if (opts.stakeRequired === void 0) terms.stakeRequired = bps > 0;
+  } else if (opts.stakeRequired === false) {
+    terms.stakeBps = 0;
+  }
+  if (opts.penaltyTo !== void 0) {
+    const parsed = PenaltyTo.safeParse(opts.penaltyTo);
+    if (!parsed.success) return { error: "--penalty-to must be one of: requester, protocol" };
+    terms.penaltyTo = parsed.data;
+  }
+  for (const [flag, value, key] of [
+    ["--review-window", opts.reviewWindow, "reviewWindowSecs"],
+    ["--decision-window", opts.decisionWindow, "decisionWindowSecs"],
+    ["--reopen-extension", opts.reopenExtension, "reopenExtensionSecs"],
+    ["--resolution-window", opts.resolutionWindow, "resolutionWindowSecs"]
+  ]) {
+    if (value === void 0) continue;
+    const secs = hoursToSecs(flag, value);
+    if (typeof secs !== "number") return secs;
+    terms[key] = secs;
+  }
+  if (opts.release !== void 0) {
+    if (opts.release !== "allowed" && opts.release !== "disallowed") {
+      return { error: "--release must be one of: allowed, disallowed" };
+    }
+    terms.releaseAllowed = opts.release === "allowed";
+  }
+  for (const [flag, value, key, max] of [
+    ["--release-grace-bps", opts.releaseGraceBps, "releaseGraceBps", 1e4],
+    ["--reject-fee-bps", opts.rejectFeeBps, "rejectFeeBps", 1e4],
+    ["--max-revisions", opts.maxRevisions, "maxRevisions", 255]
+  ]) {
+    if (value === void 0) continue;
+    const n = integer2(flag, value, max);
+    if (typeof n !== "number") return n;
+    terms[key] = n;
+  }
+  if (opts.rejectOutcome !== void 0) {
+    const parsed = RejectOutcome.safeParse(opts.rejectOutcome);
+    if (!parsed.success) return { error: "--reject-outcome must be one of: reopen, refund" };
+    terms.rejectOutcome = parsed.data;
+  }
+  return { ...termsPreset ? { termsPreset } : {}, terms };
+}
+async function fetchTermsBounds() {
+  try {
+    const response = await apiGet("/api/tasks/terms-bounds");
+    return response?.bounds ?? DEFAULT_TERMS_BOUNDS;
+  } catch {
+    return DEFAULT_TERMS_BOUNDS;
+  }
+}
+function resolveTermsForCreate(args) {
+  try {
+    return resolveTaskTerms({
+      mode: args.mode,
+      hasEvaluator: args.hasEvaluator,
+      preset: args.parsed.termsPreset,
+      overrides: args.parsed.terms,
+      bounds: args.bounds
+    });
+  } catch (error) {
+    if (error instanceof TaskTermsError) {
+      const flag = error.term ? TERM_FLAGS[error.term] : void 0;
+      return { error: flag ? `${flag}: ${error.message}` : error.message };
+    }
+    throw error;
+  }
+}
+function termsPresetLabel(terms) {
+  return terms.custom ? "custom" : terms.preset;
+}
+
+// src/commands/task/create.ts
 function parseStakeOptions(opts) {
   if (!opts.stakeRequired && opts.stakeBps === void 0) {
     return { stakeRequired: false, stakeBps: 0 };
   }
+  if (opts.stakeRequired === false) {
+    return { error: "--stake-bps cannot be combined with --no-stake-required" };
+  }
   if (opts.mode !== "claim") {
     return { error: "--stake-required and --stake-bps are only valid with --mode claim" };
   }
@@ -722,7 +1397,7 @@ function parseStakeOptions(opts) {
   }
   return { stakeRequired: true, stakeBps };
 }
-var createCmd = new Command6("create").description("Create a new task (costs the reward, in the payment token)").requiredOption("--description <text>", "Task description").requiredOption("--reward <amount>", "Reward in the payment token (e.g. 5)").requiredOption("--duration <hours>", "Task duration in hours").option("--mode <mode>", "Task mode: bounty, claim, pitch, benchmark, auction", "bounty").option(
+var createCmd = new Command7("create").description("Create a new task (costs the reward, in the payment token)").requiredOption("--description <text>", "Task description").requiredOption("--reward <amount>", "Reward in the payment token (e.g. 5)").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.",
   "public"
@@ -762,13 +1437,46 @@ var createCmd = new Command6("create").description("Create a new task (costs the
 ).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(
+  "--terms-preset <preset>",
+  "Settlement terms preset: standard (default), fast or flexible. Term flags below override it."
 ).option(
   "--stake-required",
   "Require the worker who claims the task to stake a share of the reward first (claim mode only)"
-).option(
+).option("--no-stake-required", "Require no stake, overriding the preset (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(
+  "Stake as basis points of the reward (e.g. 1000 = 10%, at most 5000). Requires --stake-required."
+).option("--penalty-to <recipient>", "Where a forfeited stake goes: requester or protocol").option(
+  "--review-window <hours>",
+  "Hours the requester has to accept, reject or ask for a revision after delivery; the worker is paid if it lapses (claim, pitch, auction without an evaluator)"
+).option(
+  "--decision-window <hours>",
+  "Hours after expiry to pick winners; after it the requester can only accept (bounty, benchmark)"
+).option(
+  "--reopen-extension <hours>",
+  "When the task reopens, its deadline moves out at least this many hours (claim, pitch)"
+).option(
+  "--release <allowed|disallowed>",
+  "Whether a worker may hand a claim back before delivery (claim mode only)"
+).option(
+  "--release-grace-bps <bps>",
+  "Share of the claim time, in bps, during which handing back is free; after it the cost rises to the full stake at expiry"
+).option(
+  "--reject-outcome <outcome>",
+  "What happens after a rejected delivery: reopen or refund (claim, pitch; auction is refund only)"
+).option(
+  "--reject-fee-bps <bps>",
+  "Share of the reward, in bps, the worker still receives on a rejected delivery"
+).option(
+  "--max-revisions <n>",
+  "How many times the requester may send work back for fixes before accepting or rejecting"
+).option("--evaluator <address>", "Evaluator address (optional)").option("--evaluator-fee-bps <bps>", "Evaluator fee in basis points (optional)").option(
+  "--evaluator-stake <amount>",
+  "Stake behind the evaluator in the payment token (e.g. 1), paid with the reward. Requires --evaluator and --yes."
+).option("--yes", "Confirm paying the evaluator stake on top of the reward", false).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)").option(
+  "--resolution-window <hours>",
+  "When the worker appeals the evaluator's verdict, the deadline moves out at least this many hours so the dispute resolver can rule (tasks with an evaluator; default 72)"
+).action(
   async (opts) => {
     let rewardBaseUnits;
     try {
@@ -777,6 +1485,29 @@ var createCmd = new Command6("create").description("Create a new task (costs the
       renderFailure(withErrorContext(err, "Invalid --reward"));
       return;
     }
+    let evaluatorStakeBaseUnits = "0";
+    if (opts.evaluatorStake !== void 0) {
+      try {
+        evaluatorStakeBaseUnits = usdcToBaseUnits(opts.evaluatorStake, { allowZero: true });
+      } catch (err) {
+        renderFailure(withErrorContext(err, "Invalid --evaluator-stake"));
+        return;
+      }
+    }
+    const evaluatorStaked = BigInt(evaluatorStakeBaseUnits) > 0n;
+    if (evaluatorStaked) {
+      if (!opts.evaluator) {
+        return void printError("--evaluator-stake requires --evaluator");
+      }
+      if (opts.sponsoredTask) {
+        return void printError("--evaluator-stake cannot be combined with --sponsored-task");
+      }
+      if (!opts.yes) {
+        return void printError(
+          `This task stakes ${opts.evaluatorStake} (${evaluatorStakeBaseUnits} base units) behind the evaluator, paid now on top of the ${opts.reward} reward (${BigInt(rewardBaseUnits) + BigInt(evaluatorStakeBaseUnits)} base units in total) and forfeitable under the task's terms. Re-run with --yes to confirm.`
+        );
+      }
+    }
     const duration = Number(opts.duration);
     if (!Number.isFinite(duration) || duration <= 0) {
       return void printError("--duration must be a positive number of hours");
@@ -844,9 +1575,9 @@ var createCmd = new Command6("create").description("Create a new task (costs the
         );
       }
     }
-    const stake = parseStakeOptions(opts);
-    if ("error" in stake) {
-      return void printError(stake.error);
+    const stakeFlags = parseStakeOptions(opts);
+    if ("error" in stakeFlags) {
+      return void printError(stakeFlags.error);
     }
     const tags = opts.tags ? opts.tags.split(",").map((t) => t.trim()) : [];
     const body = {
@@ -856,9 +1587,7 @@ var createCmd = new Command6("create").description("Create a new task (costs the
       mode: opts.mode,
       taskVisibility: opts.taskVisibility,
       submissionVisibility: opts.submissionVisibility,
-      tags,
-      stakeRequired: stake.stakeRequired,
-      stakeBps: stake.stakeBps
+      tags
     };
     if (allowedViewers && allowedViewers.length > 0) {
       body.allowedViewers = allowedViewers;
@@ -915,6 +1644,27 @@ var createCmd = new Command6("create").description("Create a new task (costs the
         "--hook-data cannot be combined with --sponsored-task -- the sponsored task funding request is the hookData"
       );
     }
+    const termsFlags = parseTermsFlags(opts);
+    if ("error" in termsFlags) {
+      return void printError(termsFlags.error);
+    }
+    const resolvedTerms = resolveTermsForCreate({
+      mode: opts.mode,
+      hasEvaluator: Boolean(opts.evaluator),
+      parsed: termsFlags,
+      bounds: await fetchTermsBounds()
+    });
+    if ("error" in resolvedTerms) {
+      return void printError(resolvedTerms.error);
+    }
+    const stake = {
+      stakeRequired: resolvedTerms.stakeRequired,
+      stakeBps: resolvedTerms.stakeBps
+    };
+    body.stakeRequired = stake.stakeRequired;
+    body.stakeBps = stake.stakeBps;
+    if (termsFlags.termsPreset) body.termsPreset = termsFlags.termsPreset;
+    if (Object.keys(termsFlags.terms).length > 0) body.terms = termsFlags.terms;
     const ethAddrRe = /^0x[0-9a-fA-F]{40}$/;
     const defaultHookAddressRe = /^0x[0-9a-f]{40}$/i;
     const hooks = opts.hook ?? [];
@@ -1050,371 +1800,28 @@ var createCmd = new Command6("create").description("Create a new task (costs the
     if (opts.evaluator) {
       body.evaluator = opts.evaluator;
       if (feeBps !== void 0) body.evaluatorFeeBps = feeBps;
+      if (evaluatorStaked) body.evaluatorStake = evaluatorStakeBaseUnits;
       if (opts.evaluationWindow) body.evaluationWindowHours = parseFloat(opts.evaluationWindow);
       if (opts.appealWindow) body.appealWindowHours = parseFloat(opts.appealWindow);
       if (opts.disputeResolver) body.disputeResolver = opts.disputeResolver;
     }
-    const { data: result, idempotencyKey } = await x402Post(
-      "/api/tasks",
-      body
-    );
-    printResult({ taskId: result.taskId }, { idempotencyKey });
-  }
-);
-
-// src/commands/task/search.ts
-import { Command as Command7 } from "commander";
-
-// src/lib/read-auth.ts
-async function signReadAuth() {
-  let keystore;
-  try {
-    keystore = await loadKeystore();
-  } catch {
-    return null;
-  }
-  try {
-    const account = await createWalletAccountFromKeystore(keystore);
-    const signature = await account.signMessage({
-      message: buildReadAuthMessage(keystore.walletAddress)
-    });
-    return {
-      walletAddress: keystore.walletAddress,
-      headers: {
-        [READ_AUTH_ADDRESS_HEADER]: keystore.walletAddress,
-        [READ_AUTH_SIGNATURE_HEADER]: signature
-      }
-    };
-  } catch {
-    return { walletAddress: keystore.walletAddress, headers: {} };
-  }
-}
-
-// src/lib/task-access-grants.ts
-import { promises as fs } from "fs";
-import path from "path";
-function getGrantsPath() {
-  return path.join(getTaskmarketHome(), "task-access-grants.json");
-}
-async function readGrantsFile() {
-  try {
-    const raw = await fs.readFile(getGrantsPath(), "utf-8");
-    return JSON.parse(raw);
-  } catch {
-    return {};
-  }
-}
-async function loadTaskAccessGrant(taskId) {
-  const grants = await readGrantsFile();
-  const record = grants[taskId];
-  if (!record) return null;
-  if (new Date(record.expiresAt).getTime() <= Date.now()) return null;
-  return record.grant;
-}
-async function taskAccessGrantHeaders(taskId) {
-  const grant = await loadTaskAccessGrant(taskId);
-  return grant ? { [TASK_ACCESS_GRANT_HEADER]: grant } : {};
-}
-async function saveTaskAccessGrant(taskId, grant, expiresAt) {
-  const grants = await readGrantsFile();
-  grants[taskId] = { grant, expiresAt };
-  const dir = path.dirname(getGrantsPath());
-  await fs.mkdir(dir, { recursive: true });
-  await fs.writeFile(getGrantsPath(), JSON.stringify(grants, null, 2), {
-    mode: 384
-  });
-}
-
-// src/sdk/artifact-upload.ts
-import { extname } from "path";
-import { Readable } from "stream";
-import https from "https";
-import http from "http";
-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 putArtifactBytes(uploadUrl, data, mimeType, onProgress) {
-  return new Promise((resolve, reject) => {
-    const url = new URL(uploadUrl);
-    const transport = url.protocol === "https:" ? https : http;
-    const req = transport.request(
-      url,
+    const { data: result, idempotencyKey } = await x402Post("/api/tasks", body);
+    const terms = result.terms ?? resolvedTerms;
+    printResult(
       {
-        method: "PUT",
-        headers: {
-          "Content-Type": mimeType,
-          "Content-Length": String(data.length)
-        }
+        taskId: result.taskId,
+        terms,
+        termsPreset: termsPresetLabel(terms),
+        ...evaluatorStaked ? { evaluatorStake: evaluatorStakeBaseUnits } : {}
       },
-      (res) => {
-        const chunks = [];
-        res.on("data", (chunk) => chunks.push(chunk));
-        res.on("end", () => {
-          if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
-            resolve();
-          } else {
-            const body = Buffer.concat(chunks).toString("utf8").slice(0, 500);
-            reject(
-              new Error(
-                `Upload failed (${res.statusCode ?? "unknown"}): ${body || "no response body"}`
-              )
-            );
-          }
-        });
-      }
+      { idempotencyKey }
     );
-    req.on("error", reject);
-    let uploaded = 0;
-    const stream = Readable.from([data]);
-    stream.on("data", (chunk) => {
-      uploaded += chunk.length;
-      onProgress?.(Math.round(uploaded / data.length * 100));
-    });
-    stream.on("error", reject);
-    stream.pipe(req);
-  });
-}
-
-// src/lib/task-sdk.ts
-async function putWithProgress(upload) {
-  process.stderr.write(`  Uploading ${upload.fileName}...
-`);
-  await putArtifactBytes(upload.uploadUrl, upload.data, upload.mimeType, (percent) => {
-    process.stderr.write(`\r  ${upload.fileName}: ${percent}%`);
-  });
-  process.stderr.write("\n");
-}
-var cliTaskTransport = {
-  get: (path3, headers) => apiGet(path3, { headers }),
-  // A write the caller gave no key is sent exactly as before the SDK existed, with no options,
-  // so `apiPost` resolves its key itself (explicit, then TASKMARKET_IDEMPOTENCY_KEY, then fresh).
-  post: (path3, body, options) => options === void 0 ? apiPost(path3, body) : apiPost(path3, body, options),
-  feePost: (path3, body, options) => x402FeePost(path3, body, options),
-  put: putWithProgress
-};
-function keystoreTaskSigner(keystore) {
-  return {
-    address: keystore.walletAddress,
-    signMessage: (message) => signMessage(message, keystore)
-  };
-}
-function cliTaskReadContext() {
-  return {
-    transport: cliTaskTransport,
-    readAuth: signReadAuth,
-    accessGrantHeaders: taskAccessGrantHeaders
-  };
-}
-function cliTaskWriteContext(keystore) {
-  return { ...cliTaskReadContext(), signer: keystoreTaskSigner(keystore) };
-}
-
-// src/sdk/tasks.ts
-import { promises as fsPromises } from "fs";
-import { basename } from "path";
-import { createHash } from "crypto";
-import { keccak256 } from "viem";
-var TaskOperationError = class extends Error {
-  code;
-  constructor(code, message) {
-    super(message);
-    this.name = "TaskOperationError";
-    this.code = code;
-  }
-};
-function withChainQuery(path3, chainId) {
-  if (chainId === void 0) return path3;
-  return `${path3}${path3.includes("?") ? "&" : "?"}chainId=${chainId}`;
-}
-function withChainBody(body, chainId) {
-  return chainId === void 0 ? body : { ...body, chainId };
-}
-function writeOptions(idempotencyKey) {
-  return idempotencyKey === void 0 ? void 0 : { idempotencyKey };
-}
-async function readAuthHeaders(ctx) {
-  return (await ctx.readAuth?.())?.headers ?? {};
-}
-async function getTask(ctx, ref) {
-  const headers = {
-    ...await readAuthHeaders(ctx),
-    ...await ctx.accessGrantHeaders?.(ref.taskId) ?? {}
-  };
-  const task = await ctx.transport.get(
-    withChainQuery(`/api/tasks/${ref.taskId}`, ref.chainId),
-    headers
-  );
-  return task ?? null;
-}
-async function listTasks(ctx, filter = {}) {
-  const params = new URLSearchParams();
-  if (filter.status) params.set("status", filter.status);
-  if (filter.phase) params.set("phase", filter.phase);
-  if (filter.mode) params.set("mode", filter.mode);
-  if (filter.auctionType) params.set("auctionType", filter.auctionType);
-  if (filter.tags) params.set("tags", filter.tags);
-  if (filter.minReward) params.set("minReward", filter.minReward);
-  if (filter.maxReward) params.set("maxReward", filter.maxReward);
-  if (filter.deadlineHours) params.set("deadlineHours", filter.deadlineHours);
-  if (filter.limit) params.set("limit", filter.limit);
-  if (filter.cursor) params.set("cursor", filter.cursor);
-  const result = await ctx.transport.get(
-    `/api/tasks?${params.toString()}`,
-    await readAuthHeaders(ctx)
-  );
-  return { tasks: result.tasks, hasMore: result.hasMore, nextCursor: result.nextCursor };
-}
-async function listTaskSubmissions(ctx, ref) {
-  const headers = await readAuthHeaders(ctx);
-  return await ctx.transport.get(
-    withChainQuery(`/api/tasks/${ref.taskId}/submissions`, ref.chainId),
-    headers
-  );
-}
-async function listWorkerSubmissions(ctx, options = {}) {
-  const auth = await ctx.readAuth?.();
-  const address = options.address ?? auth?.walletAddress;
-  if (!address) {
-    throw new TaskOperationError(
-      "no_address",
-      "No worker address was given and there is no reading wallet to default to"
-    );
-  }
-  return ctx.transport.get(`/api/submissions/mine?workerAddress=${encodeURIComponent(address)}`, {
-    ...auth?.headers ?? {}
-  });
-}
-async function claimTask(ctx, ref, options = {}) {
-  const signature = await ctx.signer.signMessage(buildClaimMessage(ref.taskId));
-  const { data, idempotencyKey } = await ctx.transport.post(
-    `/api/tasks/${ref.taskId}/claim`,
-    withChainBody({ workerAddress: ctx.signer.address, signature }, ref.chainId),
-    writeOptions(options.idempotencyKey)
-  );
-  return { claimId: data.claimId, idempotencyKey };
-}
-async function authorizeUploads(ctx, ref) {
-  return { signature: await ctx.signer.signMessage(buildSubmitMessage(ref.taskId)) };
-}
-async function readArtifactFile(file) {
-  const fileName = file.fileName ?? basename(file.path);
-  const data = await fsPromises.readFile(file.path);
-  if (data.length === 0) {
-    throw new TaskOperationError("empty_artifact", `File is empty: ${fileName}`);
-  }
-  return {
-    data,
-    artifact: {
-      fileName,
-      mimeType: file.mimeType ?? mimeTypeForPath(file.path),
-      role: file.role,
-      sizeBytes: data.length,
-      sha256Hash: createHash("sha256").update(data).digest("hex"),
-      keccak256Hash: keccak256(new Uint8Array(data))
-    }
-  };
-}
-async function requestArtifactUpload(ctx, ref, artifact, authorization) {
-  const {
-    data: { uploadUrl, artifactKey }
-  } = await ctx.transport.post(
-    `/api/tasks/${ref.taskId}/submissions/request-upload-url`,
-    withChainBody(
-      {
-        taskId: ref.taskId,
-        workerAddress: ctx.signer.address,
-        signature: authorization.signature,
-        fileName: artifact.fileName,
-        mimeType: artifact.mimeType,
-        role: artifact.role,
-        sizeBytes: artifact.sizeBytes
-      },
-      ref.chainId
-    )
-  );
-  return { uploadUrl, artifactKey };
-}
-async function uploadArtifact(ctx, ref, file, authorization) {
-  const { data, artifact } = await readArtifactFile(file);
-  const { uploadUrl, artifactKey } = await requestArtifactUpload(ctx, ref, artifact, authorization);
-  await ctx.transport.put({
-    uploadUrl,
-    data,
-    mimeType: artifact.mimeType,
-    fileName: artifact.fileName
-  });
-  return { artifactKey, ...artifact };
-}
-async function submitUploadedArtifacts(ctx, ref, artifacts, options = {}) {
-  if (artifacts.length === 0) {
-    throw new TaskOperationError("no_artifacts", "At least one artifact is required");
-  }
-  const signature = await ctx.signer.signMessage(
-    buildSubmitMessage(
-      ref.taskId,
-      artifacts.map((artifact) => artifact.artifactKey)
-    )
-  );
-  const { data, idempotencyKey } = await ctx.transport.feePost(
-    `/api/tasks/${ref.taskId}/submissions/from-keys`,
-    withChainBody(
-      {
-        taskId: ref.taskId,
-        workerAddress: ctx.signer.address,
-        artifacts,
-        signature
-      },
-      ref.chainId
-    ),
-    options
-  );
-  return { submissionId: data.submissionId, idempotencyKey };
-}
-async function submitTaskFiles(ctx, ref, files, options = {}) {
-  if (files.length === 0) {
-    throw new TaskOperationError("no_artifacts", "At least one file is required");
   }
-  const authorization = await authorizeUploads(ctx, ref);
-  const artifacts = await Promise.all(
-    files.map((file) => uploadArtifact(ctx, ref, file, authorization))
-  );
-  return submitUploadedArtifacts(ctx, ref, artifacts, options);
-}
+);
 
 // src/commands/task/search.ts
-var listCmd = new Command7("list").alias("search").description("List available tasks").option("--status <status>", "Filter by status (e.g. open)", "open").option(
+import { Command as Command8 } from "commander";
+var listCmd = new Command8("list").alias("search").description("List available tasks").option("--status <status>", "Filter by status (e.g. open)", "open").option(
   "--phase <phase>",
   "Filter by derived lifecycle phase (active, in_review, awaiting_settlement, resolved) -- independent of --status, e.g. --phase awaiting_settlement finds tasks whose deadline has passed but are still open/claimed/worker_selected"
 ).option("--mode <mode>", "Filter by mode (bounty, claim, pitch, benchmark, auction)").option(
@@ -1440,8 +1847,8 @@ var listCmd = new Command7("list").alias("search").description("List available t
 );
 
 // src/commands/task/get.ts
-import { Command as Command8 } from "commander";
-var getCmd = new Command8("get").description("Get task details").argument("<taskId>", "Task ID (0x-prefixed hex)").action(async (taskId) => {
+import { Command as Command9 } from "commander";
+var getCmd = new Command9("get").description("Get task details").argument("<taskId>", "Task ID (0x-prefixed hex)").action(async (taskId) => {
   const task = await getTask(cliTaskReadContext(), { taskId });
   if (!task) {
     printError(
@@ -1449,16 +1856,24 @@ var getCmd = new Command8("get").description("Get task details").argument("<task
     );
     return;
   }
-  printResult(task);
+  printResult({ ...task, ...await termsAmountsAndDeadlines(taskId) });
 });
+async function termsAmountsAndDeadlines(taskId) {
+  try {
+    const detail = await getTaskTerms(cliTaskReadContext(), { taskId });
+    return detail ? { termsAmounts: detail.amounts, termsDeadlines: detail.deadlines } : {};
+  } catch {
+    return {};
+  }
+}
 
 // src/commands/task/submit.ts
-import { Command as Command9, Option } from "commander";
+import { Command as Command10, Option as Option2 } from "commander";
 function collectFile(value, previous) {
   return [...previous, value];
 }
-var submitCmd = new Command9("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")
+var submitCmd = new Command10("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 Option2("--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) {
@@ -1480,8 +1895,53 @@ var submitCmd = new Command9("submit").description("Submit work for a task").arg
 });
 
 // src/commands/task/accept.ts
-import { Command as Command10 } from "commander";
-var acceptCmd = new Command10("accept").description("Accept a submission (costs 0.001 in the payment token)").argument("<taskId>", "Task ID (0x-prefixed hex)").requiredOption("--worker <addr>", "Worker wallet address").action(async (taskId, opts) => {
+import { Command as Command11 } from "commander";
+
+// src/lib/recording.ts
+var RECORDING_POLL_INTERVAL_MS = 3e3;
+var RECORDING_POLL_TIMEOUT_MS = 75e3;
+var sleepFor = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+async function settleRecording(data, idempotencyKey, options = {}) {
+  if (!isRecordingPendingResponse(data)) return {};
+  const { txHash, intentId } = data;
+  const intervalMs = options.intervalMs ?? RECORDING_POLL_INTERVAL_MS;
+  const timeoutMs = options.timeoutMs ?? RECORDING_POLL_TIMEOUT_MS;
+  const sleep4 = options.sleep ?? sleepFor;
+  const now = options.now ?? Date.now;
+  const log = options.log ?? ((line) => process.stderr.write(`${line}
+`));
+  log(
+    `Transaction ${txHash ?? "(unknown)"} is confirmed on chain; recording it is pending. Waiting up to ${Math.round(timeoutMs / 1e3)}s for the backend to record it...`
+  );
+  const headers = (await signReadAuth())?.headers ?? {};
+  const path3 = `/api/intents?idempotencyKey=${encodeURIComponent(idempotencyKey)}`;
+  const deadline = now() + timeoutMs;
+  while (now() < deadline) {
+    await sleep4(intervalMs);
+    let intent;
+    try {
+      intent = IntentStatusResponseSchema.safeParse(await apiGet(path3, { headers }));
+    } catch {
+      continue;
+    }
+    if (!intent.success) continue;
+    if (intent.data.status === "completed") return { status: "recorded" };
+    if (intent.data.status === "failed") {
+      throw new Error(
+        `Transaction ${txHash ?? "(unknown)"} confirmed, but the backend marked the write failed: ${intent.data.terminalReason ?? "no reason recorded"}`
+      );
+    }
+  }
+  return {
+    status: "recording_pending",
+    ...txHash !== void 0 ? { txHash } : {},
+    ...intentId !== void 0 ? { intentId } : {},
+    nextStep: `The transaction is confirmed on chain and the backend retries the recording automatically. Do not re-run this command; check later with GET /api/intents?idempotencyKey=${idempotencyKey}.`
+  };
+}
+
+// src/commands/task/accept.ts
+var acceptCmd = new Command11("accept").description("Accept a submission (costs 0.001 in the payment token)").argument("<taskId>", "Task ID (0x-prefixed hex)").requiredOption("--worker <addr>", "Worker wallet address").action(async (taskId, opts) => {
   const task = await getTask(cliTaskReadContext(), { taskId });
   if (!task) {
     printError(
@@ -1500,19 +1960,22 @@ var acceptCmd = new Command10("accept").description("Accept a submission (costs
       (a) => a.action === "select_worker" && a.role === "requester"
     );
     printError(
-      hasRefund ? "Task has expired with no submissions. Use taskmarket task refund-expired to recover escrow." : hasSelectWorker ? "Pitch window has closed. Use taskmarket task select-worker to pick from received pitches, or cancel the task." : "Accept is not available for this task in its current state."
+      hasRefund ? "Task has expired and can no longer be accepted. Use taskmarket task refund-expired to recover escrow." : hasSelectWorker ? "Pitch window has closed. Use taskmarket task select-worker to pick from received pitches, or cancel the task." : "Accept is not available for this task in its current state."
     );
     return;
   }
-  const { idempotencyKey } = await x402Post(`/api/tasks/${taskId}/accept`, {
+  const { data: result, idempotencyKey } = await x402Post(`/api/tasks/${taskId}/accept`, {
     taskId,
     worker: opts.worker
   });
-  printResult({ accepted: true }, { idempotencyKey });
+  printResult(
+    { accepted: true, ...await settleRecording(result, idempotencyKey) },
+    { idempotencyKey }
+  );
 });
 
 // src/commands/task/accept-submissions.ts
-import { Command as Command11 } from "commander";
+import { Command as Command12 } from "commander";
 function parseWinner(spec) {
   const parts = spec.split(":");
   if (parts.length < 2 || parts.length > 3) {
@@ -1531,7 +1994,7 @@ function parseWinner(spec) {
   const submissionId = submissionIdStr ? submissionIdStr : void 0;
   return { worker, share, ...submissionId !== void 0 && { submissionId } };
 }
-var acceptSubmissionsCmd = new Command11("accept-submissions").description(
+var acceptSubmissionsCmd = new Command12("accept-submissions").description(
   "Accept N submissions for a Bounty/Benchmark task with explicit share basis points (costs 0.001 in the payment token).\nShares must sum to 10000. The contract resolves each deliverable from on-chain submission history.\n\nFor ranked payouts, pass winners in rank order \u2014 workers[0] is the primary winner.\n\nTo pin a specific submission version, append the submission ID as a third field.\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_abc123 --winner 0xBob:5000:sub_def456"
 ).argument("<taskId>", "Task ID (0x-prefixed hex)").requiredOption(
   "--winner <spec...>",
@@ -1550,15 +2013,22 @@ var acceptSubmissionsCmd = new Command11("accept-submissions").description(
         winners
       }
     );
-    printResult({ accepted: result.success, winners: winners.length }, { idempotencyKey });
+    printResult(
+      {
+        accepted: result.success,
+        winners: winners.length,
+        ...await settleRecording(result, idempotencyKey)
+      },
+      { idempotencyKey }
+    );
   } catch (err) {
     renderFailure(err);
   }
 });
 
 // src/commands/task/rate.ts
-import { Command as Command12 } from "commander";
-var rateCmd = new Command12("rate").description("Rate a worker (costs 0.001 in the payment token)").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) => {
+import { Command as Command13 } from "commander";
+var rateCmd = new Command13("rate").description("Rate a worker (costs 0.001 in the payment token)").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");
@@ -1570,24 +2040,92 @@ var rateCmd = new Command12("rate").description("Rate a worker (costs 0.001 in t
     rating,
     ...opts.feedback ? { feedbackText: opts.feedback } : {}
   });
-  printResult({ feedbackId: result.feedbackId }, { idempotencyKey });
+  printResult(
+    { feedbackId: result.feedbackId, ...await settleRecording(result, idempotencyKey) },
+    { idempotencyKey }
+  );
 });
 
 // src/commands/task/claim.ts
-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) => {
+import { Command as Command14 } from "commander";
+
+// src/lib/stake-confirmation.ts
+async function confirmStakeTerms(action, taskId, yes) {
+  if (yes) return true;
+  let detail;
+  try {
+    detail = await getTaskTerms(cliTaskReadContext(), { taskId });
+  } catch {
+    return true;
+  }
+  if (!detail?.terms.stakeRequired) return true;
+  if (detail.amounts.enforcedStakeAmount === "0") return true;
+  const stakeAmount = detail.amounts.enforcedStakeAmount ?? detail.amounts.stakeAmount;
+  renderFailure(
+    new Error(
+      `This task requires a stake of ${stakeAmount} base units (${detail.terms.stakeBps} bps of the reward) to ${action}. Review the terms, then re-run with --yes to accept them.`
+    ),
+    {
+      details: {
+        code: "stake_confirmation_required",
+        terms: detail.terms,
+        amounts: detail.amounts,
+        deadlines: detail.deadlines
+      }
+    }
+  );
+  return false;
+}
+async function confirmStakeAffordable(address, stake) {
+  if (stake <= 0n) return true;
+  let balance;
+  try {
+    const result = await apiGet(
+      `/api/wallet/balance?address=${address}&chainId=${selectedNetwork().chainId}`
+    );
+    if (typeof result?.balanceBaseUnits !== "string") return true;
+    balance = BigInt(result.balanceBaseUnits);
+  } catch {
+    return true;
+  }
+  if (balance >= stake) return true;
+  renderFailure(
+    new Error(
+      `This claim needs a stake of ${stake} base units, and the wallet holds ${balance}. Fund the wallet (taskmarket deposit), then claim again.`
+    ),
+    {
+      details: {
+        code: "stake_balance_short",
+        stakeAmount: stake.toString(),
+        balance: balance.toString()
+      }
+    }
+  );
+  return false;
+}
+
+// src/commands/task/claim.ts
+var claimCmd = new Command14("claim").description("Claim a task as a worker").argument("<taskId>", "Task ID (0x-prefixed hex)").option("--yes", "Accept the task's settlement terms, including paying any required stake").action(async (taskId, opts) => {
+  if (!await confirmStakeTerms("claim", taskId, opts.yes)) return;
+  const task = await getTask(cliTaskReadContext(), { taskId });
+  const stake = task ? claimStakeToPost(task) : 0n;
   const keystore = await loadKeystore();
+  if (!await confirmStakeAffordable(keystore.walletAddress, stake)) return;
   const { claimId, idempotencyKey } = await claimTask(cliTaskWriteContext(keystore), { taskId });
-  printResult({ claimId }, { idempotencyKey });
+  printResult(
+    { claimId, ...stake > 0n ? { stake: stake.toString() } : {} },
+    { idempotencyKey }
+  );
 });
 
 // src/commands/task/pitch.ts
-import { Command as Command14 } from "commander";
-var pitchCmd = new Command14("pitch").description(
+import { Command as Command15 } from "commander";
+var pitchCmd = new Command15("pitch").description(
   "Submit a pitch for a task (costs 0.001 in the payment token, 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) => {
+).argument("<taskId>", "Task ID (0x-prefixed hex)").requiredOption("--text <text>", "Pitch text").option("--duration <hours>", "Estimated duration in hours").option("--yes", "Accept the task's settlement terms, including any required stake").action(async (taskId, opts) => {
+  if (!await confirmStakeTerms("pitch", taskId, opts.yes)) return;
   const keystore = await loadKeystore();
-  const signature = await signMessage(`taskmarket:pitch:${taskId}`, keystore);
+  const signature = await signMessage(buildPitchMessage(taskId), keystore);
   const { data: result, idempotencyKey } = await x402Post(
     `/api/tasks/${taskId}/pitches`,
     {
@@ -1602,8 +2140,8 @@ var pitchCmd = new Command14("pitch").description(
 });
 
 // src/commands/task/pitches.ts
-import { Command as Command15 } from "commander";
-var pitchesCmd = new Command15("pitches").description("List pitches for a task").argument("<taskId>", "Task ID (0x-prefixed hex)").action(async (taskId) => {
+import { Command as Command16 } from "commander";
+var pitchesCmd = new Command16("pitches").description("List pitches for a task").argument("<taskId>", "Task ID (0x-prefixed hex)").action(async (taskId) => {
   try {
     const auth = await signReadAuth();
     const headers = { ...auth?.headers ?? {}, ...await taskAccessGrantHeaders(taskId) };
@@ -1614,25 +2152,28 @@ var pitchesCmd = new Command15("pitches").description("List pitches for a task")
 });
 
 // src/commands/task/select-worker.ts
-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) => {
+import { Command as Command17 } from "commander";
+var selectWorkerCmd = new Command17("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 { idempotencyKey } = await x402Post(`/api/tasks/${taskId}/pitches/select`, {
+  const { data: result, idempotencyKey } = await x402Post(`/api/tasks/${taskId}/pitches/select`, {
     taskId,
     pitchId: opts.pitch,
     workerAddress: opts.worker,
     signature
   });
-  printResult({ selected: true }, { idempotencyKey });
+  printResult(
+    { selected: true, ...await settleRecording(result, idempotencyKey) },
+    { idempotencyKey }
+  );
 });
 
 // src/commands/task/proof.ts
-import { Command as Command17 } from "commander";
-var proofCmd = new Command17("proof").description("Submit a benchmark proof (costs 0.001 in the payment token, 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) => {
+import { Command as Command18 } from "commander";
+var proofCmd = new Command18("proof").description("Submit a benchmark proof (costs 0.001 in the payment token, 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 signature = await signMessage(buildProofMessage(taskId), keystore);
   const { data: result, idempotencyKey } = await x402Post(`/api/tasks/${taskId}/proofs`, {
     taskId,
     workerAddress: keystore.walletAddress,
@@ -1645,8 +2186,8 @@ var proofCmd = new Command17("proof").description("Submit a benchmark proof (cos
 });
 
 // src/commands/task/proofs.ts
-import { Command as Command18 } from "commander";
-var proofsCmd = new Command18("proofs").description("List proofs for a benchmark task").argument("<taskId>", "Task ID (0x-prefixed hex)").action(async (taskId) => {
+import { Command as Command19 } from "commander";
+var proofsCmd = new Command19("proofs").description("List proofs for a benchmark task").argument("<taskId>", "Task ID (0x-prefixed hex)").action(async (taskId) => {
   try {
     const auth = await signReadAuth();
     const headers = { ...auth?.headers ?? {}, ...await taskAccessGrantHeaders(taskId) };
@@ -1657,8 +2198,8 @@ var proofsCmd = new Command18("proofs").description("List proofs for a benchmark
 });
 
 // src/commands/task/bid.ts
-import { Command as Command19 } from "commander";
-var bidCmd = new Command19("bid").description("Submit a bid on an auction task").argument("<taskId>", "Task ID (0x-prefixed hex)").requiredOption("--price <amount>", "Bid price in the payment token (e.g. 3 or 1.5)").action(async (taskId, opts) => {
+import { Command as Command20 } from "commander";
+var bidCmd = new Command20("bid").description("Submit a bid on an auction task").argument("<taskId>", "Task ID (0x-prefixed hex)").requiredOption("--price <amount>", "Bid price in the payment token (e.g. 3 or 1.5)").option("--yes", "Accept the task's settlement terms, including any required stake").action(async (taskId, opts) => {
   let priceBaseUnits;
   try {
     priceBaseUnits = usdcToBaseUnits(opts.price);
@@ -1666,6 +2207,7 @@ var bidCmd = new Command19("bid").description("Submit a bid on an auction task")
     renderFailure(withErrorContext(err, "Invalid --price"));
     return;
   }
+  if (!await confirmStakeTerms("bid", taskId, opts.yes)) return;
   const { data: result, idempotencyKey } = await x402Post(
     `/api/tasks/${taskId}/bids`,
     {
@@ -1677,8 +2219,8 @@ var bidCmd = new Command19("bid").description("Submit a bid on an auction task")
 });
 
 // src/commands/task/auction-accept.ts
-import { Command as Command20 } from "commander";
-var auctionAcceptCmd = new Command20("auction-accept").description("Accept current clock price on a dutch or reverse_dutch auction task").argument("<taskId>", "Task ID (0x-prefixed hex)").option(
+import { Command as Command21 } from "commander";
+var auctionAcceptCmd = new Command21("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 <amount>",
   "Reject if current clock price is below this value (price floor guard)"
 ).action(async (taskId, opts) => {
@@ -1692,19 +2234,24 @@ var auctionAcceptCmd = new Command20("auction-accept").description("Accept curre
     }
   }
   const { data: result, idempotencyKey } = await x402Post(`/api/tasks/${taskId}/bids/accept`, body);
+  const { chainId } = selectedNetwork();
   printResult(
     {
       acceptedPrice: result.acceptedPrice,
+      // Field name kept for scripts; the number is in the selected network's payment token.
       acceptedPriceUsdc: formatUsdcBaseUnits(result.acceptedPrice),
-      workerAddress: result.workerAddress
+      acceptedPriceFormatted: formatPaymentAmount(result.acceptedPrice, chainId),
+      tokenSymbol: paymentTokenSymbol(chainId),
+      workerAddress: result.workerAddress,
+      ...await settleRecording(result, idempotencyKey)
     },
     { idempotencyKey }
   );
 });
 
 // src/commands/task/submissions.ts
-import { Command as Command21 } from "commander";
-var submissionsCmd = new Command21("submissions").description("List submissions for a task").argument("<taskId>", "Task ID (0x-prefixed hex)").action(async (taskId) => {
+import { Command as Command22 } from "commander";
+var submissionsCmd = new Command22("submissions").description("List submissions for a task").argument("<taskId>", "Task ID (0x-prefixed hex)").action(async (taskId) => {
   let subs;
   try {
     subs = await listTaskSubmissions(cliTaskReadContext(), { taskId });
@@ -1716,8 +2263,8 @@ var submissionsCmd = new Command21("submissions").description("List submissions
 });
 
 // src/commands/task/select-winner.ts
-import { Command as Command22 } from "commander";
-var selectWinnerCmd = new Command22("select-winner").description("Permissionlessly finalize the lowest bidder after the auction deadline").argument("<taskId>", "Task ID (0x-prefixed hex)").action(async (taskId) => {
+import { Command as Command23 } from "commander";
+var selectWinnerCmd = new Command23("select-winner").description("Permissionlessly finalize the lowest bidder after the auction deadline").argument("<taskId>", "Task ID (0x-prefixed hex)").action(async (taskId) => {
   let result;
   let idempotencyKey;
   try {
@@ -1732,13 +2279,32 @@ var selectWinnerCmd = new Command22("select-winner").description("Permissionless
   printResult(result, { idempotencyKey });
 });
 
+// src/commands/task/start-review.ts
+import { Command as Command24 } from "commander";
+var startReviewCmd = new Command24("start-review").description(
+  "Start the review window on a delivery made before the settlement-terms upgrade that has none yet (anyone may call). Once the window lapses undecided, `task settle` pays the worker."
+).argument("<taskId>", "Task ID (0x-prefixed hex)").action(async (taskId) => {
+  try {
+    const { data: result, idempotencyKey } = await apiPost(
+      `/api/tasks/${taskId}/start-review`,
+      { taskId }
+    );
+    printResult(
+      { ...result, ...await settleRecording(result, idempotencyKey) },
+      { idempotencyKey }
+    );
+  } catch (err) {
+    renderFailure(err);
+  }
+});
+
 // src/commands/task/download.ts
-import { Command as Command23 } from "commander";
+import { Command as Command25 } from "commander";
 import { writeFileSync } from "fs";
 function sanitizeForTerminal(text) {
   return text.replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g, "");
 }
-var downloadCmd = new Command23("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(
+var downloadCmd = new Command25("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;
@@ -1786,38 +2352,90 @@ var downloadCmd = new Command23("download").description("Download a submission f
 );
 
 // src/commands/task/cancel.ts
-import { Command as Command24 } from "commander";
-var cancelCmd = new Command24("cancel").description(
+import { Command as Command26 } from "commander";
+
+// src/lib/decision-window.ts
+var DECISION_WINDOW_LAPSED_CODE = "decision_window_lapsed";
+async function decisionWindowLapse(taskId, options) {
+  try {
+    const detail = await getTaskTerms(cliTaskReadContext(), { taskId });
+    if (!detail || detail.chainSupportsTerms !== true) return null;
+    const deadline = detail.deadlines?.decisionDeadline;
+    if (!deadline) return null;
+    if (Date.parse(deadline) > (options.now ?? Date.now())) return null;
+    if (options.requireLiveSubmissions) {
+      const submissions = await apiGet(`/api/tasks/${taskId}/submissions`);
+      if (!Array.isArray(submissions) || !submissions.some((s) => s.rejectedAt == null)) {
+        return null;
+      }
+    }
+    return { decisionDeadline: deadline };
+  } catch {
+    return null;
+  }
+}
+function renderDecisionWindowLapsed(action, lapse) {
+  renderFailure(
+    new Error(
+      `The decision window closed at ${lapse.decisionDeadline} with submissions still live: ${action} would revert on chain (DecisionWindowLapsed). Accept a winner to settle the task.`
+    ),
+    { details: { code: DECISION_WINDOW_LAPSED_CODE, decisionDeadline: lapse.decisionDeadline } }
+  );
+}
+
+// src/commands/task/cancel.ts
+var cancelCmd = new Command26("cancel").description(
   "Cancel an open task and refund the escrowed reward (costs 0.001 in the payment token)"
 ).argument("<taskId>", "Task ID (0x-prefixed hex)").action(async (taskId) => {
+  const lapse = await decisionWindowLapse(taskId, { requireLiveSubmissions: true });
+  if (lapse) {
+    renderDecisionWindowLapsed("cancel", lapse);
+    return;
+  }
   const { data: result, idempotencyKey } = await x402Post(
     `/api/tasks/${taskId}/cancel`,
     { taskId }
   );
-  printResult(result, { idempotencyKey });
+  printResult(
+    { ...result, ...await settleRecording(result, idempotencyKey) },
+    { idempotencyKey }
+  );
 });
 
 // src/commands/task/refund-expired.ts
-import { Command as Command25 } from "commander";
-var refundExpiredCmd = new Command25("refund-expired").description(
-  "Refund an expired task with no submissions back to the requester (costs 0.001 in the payment token)"
+import { Command as Command27 } from "commander";
+var refundExpiredCmd = new Command27("refund-expired").description(
+  "Refund an expired task back to the requester; bounty and benchmark tasks need every submission rejected first (costs 0.001 in the payment token)"
 ).argument("<taskId>", "Task ID (0x-prefixed hex)").action(async (taskId) => {
+  const lapse = await decisionWindowLapse(taskId, { requireLiveSubmissions: true });
+  if (lapse) {
+    renderDecisionWindowLapsed("refund-expired", lapse);
+    return;
+  }
   try {
     const { data: result, idempotencyKey } = await x402Post(
       `/api/tasks/${taskId}/refund-expired`,
       { taskId }
     );
-    printResult(result, { idempotencyKey });
+    printResult(
+      { ...result, ...await settleRecording(result, idempotencyKey) },
+      { idempotencyKey }
+    );
   } catch (err) {
     renderFailure(err);
   }
 });
 
 // src/commands/task/reject-submission.ts
-import { Command as Command26 } from "commander";
-var rejectSubmissionCmd = new Command26("reject-submission").description(
+import { Command as Command28 } from "commander";
+var rejectSubmissionCmd = new Command28("reject-submission").description(
   "Reject a spam or low-quality submission (costs a 0.001 relay fee in the payment token). Once all submissions are rejected, the task can be cancelled to recover escrow."
 ).argument("<taskId>", "Task ID (0x-prefixed hex)").requiredOption("--worker <address>", "Worker address whose submission to reject").action(async (taskId, opts) => {
+  const lapse = await decisionWindowLapse(taskId, { requireLiveSubmissions: false });
+  if (lapse) {
+    renderDecisionWindowLapsed("reject-submission", lapse);
+    return;
+  }
   try {
     const { data: result, idempotencyKey } = await x402Post(
       `/api/tasks/${taskId}/reject-submission`,
@@ -1826,14 +2444,17 @@ var rejectSubmissionCmd = new Command26("reject-submission").description(
         worker: opts.worker
       }
     );
-    printResult(result, { idempotencyKey });
+    printResult(
+      { ...result, ...await settleRecording(result, idempotencyKey) },
+      { idempotencyKey }
+    );
   } catch (err) {
     renderFailure(err);
   }
 });
 
 // src/commands/task/reject-all-submissions.ts
-import { Command as Command27 } from "commander";
+import { Command as Command29 } from "commander";
 function activeSubmissionWorkers(submissions) {
   const workers = /* @__PURE__ */ new Map();
   for (const submission of submissions) {
@@ -1843,7 +2464,7 @@ function activeSubmissionWorkers(submissions) {
   }
   return [...workers.values()];
 }
-var rejectAllSubmissionsCmd = new Command27("reject-all-submissions").description(
+var rejectAllSubmissionsCmd = new Command29("reject-all-submissions").description(
   "Reject every active submission on a bounty or benchmark task in one go. Lists active submissions, rejects each unique worker in sequence, then cancels the task. Use this to recover escrow when all submitted work is unsuitable."
 ).argument("<taskId>", "Task ID (0x-prefixed hex)").option("--no-cancel", "Reject all submissions but do not cancel the task afterward").action(async (taskId, opts) => {
   let submissions;
@@ -1858,6 +2479,11 @@ var rejectAllSubmissionsCmd = new Command27("reject-all-submissions").descriptio
     printResult({ rejected: 0, message: "no active submissions to reject" });
     return;
   }
+  const lapse = await decisionWindowLapse(taskId, { requireLiveSubmissions: false });
+  if (lapse) {
+    renderDecisionWindowLapsed("reject-all-submissions", lapse);
+    return;
+  }
   const results = [];
   for (const worker of workers) {
     try {
@@ -1916,8 +2542,8 @@ var rejectAllSubmissionsCmd = new Command27("reject-all-submissions").descriptio
 });
 
 // src/commands/task/my-submissions.ts
-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) => {
+import { Command as Command30 } from "commander";
+var mySubmissionsCmd = new Command30("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 result = await listWorkerSubmissions(cliTaskReadContext(), { address: opts.address });
     printResult(result);
@@ -1929,8 +2555,8 @@ var mySubmissionsCmd = new Command28("my-submissions").description("List all sub
 });
 
 // src/commands/task/update.ts
-import { Command as Command29 } from "commander";
-var updateCmd = new Command29("update").description("Update an open task (costs 0.001 plus any reward increase, in the payment token)").argument("<taskId>", "Task ID (0x-prefixed hex)").option("--reward <amount>", 'New reward in the payment token (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 <amount>", "New auction floor price in the payment token").option("--auction-start-price <amount>", "New auction start price in the payment token").option("--description <text>", "New description").option("--tags <csv>", "New tags (comma-separated)").option("--metric-description <text>", "New metric description").action(
+import { Command as Command31 } from "commander";
+var updateCmd = new Command31("update").description("Update an open task (costs 0.001 plus any reward increase, in the payment token)").argument("<taskId>", "Task ID (0x-prefixed hex)").option("--reward <amount>", 'New reward in the payment token (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 <amount>", "New auction floor price in the payment token").option("--auction-start-price <amount>", "New auction start price in the payment token").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) {
@@ -2018,8 +2644,8 @@ var updateCmd = new Command29("update").description("Update an open task (costs
 );
 
 // src/commands/task/forfeit.ts
-import { Command as Command30 } from "commander";
-var forfeitCmd = new Command30("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) => {
+import { Command as Command32 } from "commander";
+var forfeitCmd = new Command32("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 keystore = await loadKeystore();
     const message = buildForfeitMessage(taskId);
@@ -2032,18 +2658,24 @@ var forfeitCmd = new Command30("forfeit").description("Reclaim a claim-mode task
         signature
       }
     );
-    printResult(result, { idempotencyKey });
+    printResult(
+      { ...result, ...await settleRecording(result, idempotencyKey) },
+      { idempotencyKey }
+    );
   } catch (err) {
     renderFailure(err);
   }
 });
 
 // src/commands/task/assign-evaluator.ts
-import { Command as Command31 } from "commander";
+import { Command as Command33 } from "commander";
 var ADDRESS_PATTERN = /^0x[0-9a-fA-F]{40}$/;
-var assignEvaluatorCmd = new Command31("assign-evaluator").description(
+var assignEvaluatorCmd = new Command33("assign-evaluator").description(
   "Assign an evaluator to an open, unclaimed task you requested (costs 0.001 in the payment token). Only possible before a worker claims the task."
-).argument("<taskId>", "Task ID (0x-prefixed hex)").requiredOption("--evaluator <address>", "Evaluator wallet address").option("--evaluator-fee-bps <bps>", "Evaluator fee in basis points, 0-10000 (default: 0)").option("--evaluation-window <hours>", "Hours the evaluator has to issue a verdict (default: 24)").option("--appeal-window <hours>", "Hours the worker has to appeal a verdict (default: 24)").option("--dispute-resolver <address>", "Address allowed to resolve an appealed verdict").action(
+).argument("<taskId>", "Task ID (0x-prefixed hex)").requiredOption("--evaluator <address>", "Evaluator wallet address").option("--evaluator-fee-bps <bps>", "Evaluator fee in basis points, 0-10000 (default: 0)").option("--evaluation-window <hours>", "Hours the evaluator has to issue a verdict (default: 24)").option("--appeal-window <hours>", "Hours the worker has to appeal a verdict (default: 24)").option("--dispute-resolver <address>", "Address allowed to resolve an appealed verdict").option(
+  "--evaluator-stake <amount>",
+  "Stake behind the evaluator in the payment token (e.g. 1), paid with the action fee. Requires --yes."
+).option("--yes", "Confirm paying the evaluator stake", false).action(
   async (taskId, opts) => {
     if (!ADDRESS_PATTERN.test(opts.evaluator)) {
       return void printError(`--evaluator must be a wallet address, got: ${opts.evaluator}`);
@@ -2053,7 +2685,23 @@ var assignEvaluatorCmd = new Command31("assign-evaluator").description(
         `--dispute-resolver must be a wallet address, got: ${opts.disputeResolver}`
       );
     }
+    let evaluatorStake = "0";
+    if (opts.evaluatorStake !== void 0) {
+      try {
+        evaluatorStake = usdcToBaseUnits(opts.evaluatorStake, { allowZero: true });
+      } catch (err) {
+        renderFailure(withErrorContext(err, "Invalid --evaluator-stake"));
+        return;
+      }
+    }
+    const staked = BigInt(evaluatorStake) > 0n;
+    if (staked && !opts.yes) {
+      return void printError(
+        `This assignment stakes ${opts.evaluatorStake} (${evaluatorStake} base units) behind the evaluator, paid now with the action fee and forfeitable under the task's terms. Re-run with --yes to confirm.`
+      );
+    }
     const body = { taskId, evaluator: opts.evaluator };
+    if (staked) body.evaluatorStake = evaluatorStake;
     if (opts.evaluatorFeeBps !== void 0) {
       const bps = Number(opts.evaluatorFeeBps);
       if (!Number.isInteger(bps) || bps < 0 || bps > 1e4) {
@@ -2088,16 +2736,19 @@ var assignEvaluatorCmd = new Command31("assign-evaluator").description(
       `/api/tasks/${taskId}/evaluator`,
       body
     );
-    printResult(result, { idempotencyKey });
+    printResult(
+      { ...result, ...await settleRecording(result, idempotencyKey) },
+      { idempotencyKey }
+    );
   }
 );
 
 // src/commands/task/evaluate.ts
-import { Command as Command32 } from "commander";
-var evaluateCmd = new Command32("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(
+import { Command as Command34 } from "commander";
+var evaluateCmd = new Command34("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:amount:rank",
-  collect,
+  collect2,
   []
 ).action(
   async (taskId, opts) => {
@@ -2149,40 +2800,52 @@ var evaluateCmd = new Command32("evaluate").description("Submit an evaluation ve
       `/api/tasks/${taskId}/evaluate`,
       body
     );
-    printResult({ txHash: result.txHash }, { idempotencyKey });
+    printResult(
+      { txHash: result.txHash, ...await settleRecording(result, idempotencyKey) },
+      { idempotencyKey }
+    );
   }
 );
-function collect(val, prev) {
+function collect2(val, prev) {
   return prev.concat([val]);
 }
 
 // src/commands/task/appeal.ts
-import { Command as Command33 } from "commander";
-var appealCmd = new Command33("appeal").description("Appeal an evaluator verdict while in Appealing state").argument("<taskId>", "Task ID (0x-prefixed hex)").action(async (taskId) => {
+import { Command as Command35 } from "commander";
+var appealCmd = new Command35("appeal").description("Appeal an evaluator verdict while in Appealing state").argument("<taskId>", "Task ID (0x-prefixed hex)").action(async (taskId) => {
   const { data: result, idempotencyKey } = await x402Post(`/api/tasks/${taskId}/appeal`, { taskId });
-  printResult({ txHash: result.txHash }, { idempotencyKey });
+  printResult(
+    { txHash: result.txHash, ...await settleRecording(result, idempotencyKey) },
+    { idempotencyKey }
+  );
 });
 
 // src/commands/task/evaluator-timeout.ts
-import { Command as Command34 } from "commander";
-var evaluatorTimeoutCmd = new Command34("evaluator-timeout").description("Trigger evaluator timeout after the evaluation window expires (requester only)").argument("<taskId>", "Task ID (0x-prefixed hex)").action(async (taskId) => {
+import { Command as Command36 } from "commander";
+var evaluatorTimeoutCmd = new Command36("evaluator-timeout").description("Trigger evaluator timeout after the evaluation window expires (anyone)").argument("<taskId>", "Task ID (0x-prefixed hex)").action(async (taskId) => {
   const { data: result, idempotencyKey } = await x402Post(`/api/tasks/${taskId}/evaluator-timeout`, { taskId });
-  printResult({ txHash: result.txHash }, { idempotencyKey });
+  printResult(
+    { txHash: result.txHash, ...await settleRecording(result, idempotencyKey) },
+    { idempotencyKey }
+  );
 });
 
 // src/commands/task/finalize-verdict.ts
-import { Command as Command35 } from "commander";
-var finalizeVerdictCmd = new Command35("finalize-verdict").description("Finalize an evaluator verdict after the appeal window expires (permissionless)").argument("<taskId>", "Task ID (0x-prefixed hex)").action(async (taskId) => {
+import { Command as Command37 } from "commander";
+var finalizeVerdictCmd = new Command37("finalize-verdict").description("Finalize an evaluator verdict after the appeal window expires (permissionless)").argument("<taskId>", "Task ID (0x-prefixed hex)").action(async (taskId) => {
   const { data: result, idempotencyKey } = await apiPost(`/api/tasks/${taskId}/finalize-verdict`, { taskId });
-  printResult({ txHash: result.txHash }, { idempotencyKey });
+  printResult(
+    { txHash: result.txHash, ...await settleRecording(result, idempotencyKey) },
+    { idempotencyKey }
+  );
 });
 
 // src/commands/task/resolve-dispute.ts
-import { Command as Command36 } from "commander";
+import { Command as Command38 } 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>`);
+    throw new Error(`Invalid --award value "${spec}". Expected <addr>:<amount>:<rank>`);
   }
   const [worker, amountStr, rankStr] = parts;
   if (!/^0x[0-9a-fA-F]{40}$/.test(worker)) {
@@ -2199,11 +2862,11 @@ function parseAward(spec) {
     rank
   };
 }
-var resolveDisputeCmd = new Command36("resolve-dispute").description(
+var resolveDisputeCmd = new Command38("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."
+  "Award spec <addr>:<amount>:<rank>, amount in whole payment tokens (USDC on Base, OUSD on Tempo). Pass multiple times."
 ).action(async (taskId, opts) => {
   if (opts.verdict !== "approve" && opts.verdict !== "partial") {
     printError('--verdict must be "approve" or "partial"');
@@ -2224,12 +2887,15 @@ var resolveDisputeCmd = new Command36("resolve-dispute").description(
       awards
     }
   );
-  printResult({ txHash: result.txHash }, { idempotencyKey });
+  printResult(
+    { txHash: result.txHash, ...await settleRecording(result, idempotencyKey) },
+    { idempotencyKey }
+  );
 });
 
 // src/commands/task/unlock.ts
-import { Command as Command37 } from "commander";
-var unlockCmd = new Command37("unlock").description("Unlock a private task with its password, caching a task-scoped access grant").argument("<taskId>", "Task ID (0x-prefixed hex)").requiredOption("--password <password>", "The private task's password").action(async (taskId, opts) => {
+import { Command as Command39 } from "commander";
+var unlockCmd = new Command39("unlock").description("Unlock a private task with its password, caching a task-scoped access grant").argument("<taskId>", "Task ID (0x-prefixed hex)").requiredOption("--password <password>", "The private task's password").action(async (taskId, opts) => {
   let result;
   let idempotencyKey;
   try {
@@ -2246,8 +2912,8 @@ 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, address) => {
+import { Command as Command40 } from "commander";
+var inviteCmd = new Command40("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, address) => {
   const auth = await signReadAuth();
   if (!auth || Object.keys(auth.headers).length === 0) {
     printError("No keystore found. Run `taskmarket init` first.");
@@ -2266,8 +2932,8 @@ 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, address) => {
+import { Command as Command41 } from "commander";
+var uninviteCmd = new Command41("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, address) => {
   const auth = await signReadAuth();
   if (!auth || Object.keys(auth.headers).length === 0) {
     printError("No keystore found. Run `taskmarket init` first.");
@@ -2285,8 +2951,8 @@ var uninviteCmd = new Command39("uninvite").description("Remove a wallet from a
 });
 
 // src/commands/task/viewers.ts
-import { Command as Command40 } from "commander";
-var viewersCmd = new Command40("viewers").description("List a private task's wallet allowlist (requester only)").argument("<taskId>", "Task ID (0x-prefixed hex)").action(async (taskId) => {
+import { Command as Command42 } from "commander";
+var viewersCmd = new Command42("viewers").description("List a private task's wallet allowlist (requester only)").argument("<taskId>", "Task ID (0x-prefixed hex)").action(async (taskId) => {
   const auth = await signReadAuth();
   if (!auth || Object.keys(auth.headers).length === 0) {
     printError("No keystore found. Run `taskmarket init` first.");
@@ -2302,49 +2968,173 @@ var viewersCmd = new Command40("viewers").description("List a private task's wal
   }
 });
 
+// src/commands/task/terms.ts
+import { Command as Command43 } from "commander";
+var termsCmd = new Command43("terms").description(
+  "Show a task's settlement terms: stake, review window, reject fee and outcome, revisions, release cost now and deadlines"
+).argument("<taskId>", "Task ID (0x-prefixed hex)").action(async (taskId) => {
+  const detail = await getTaskTerms(cliTaskReadContext(), { taskId });
+  if (!detail) {
+    printError(
+      `Task not found: ${taskId} (or this is a private task you don't have access to -- if you have a password for it, run: taskmarket task unlock ${taskId} --password <password>)`
+    );
+    return;
+  }
+  printResult(detail);
+});
+
+// src/lib/settlement-action.ts
+import { Command as Command44 } from "commander";
+async function readTerms(taskId) {
+  try {
+    return await getTaskTerms(cliTaskReadContext(), { taskId });
+  } catch {
+    return null;
+  }
+}
+async function confirmSettlementAction(name, confirm2, taskId, yes) {
+  if (!confirm2 || yes) return true;
+  const detail = await readTerms(taskId);
+  const termsDetails = detail ? { terms: detail.terms, amounts: detail.amounts, deadlines: detail.deadlines } : {};
+  if (confirm2 === "release-cost") {
+    if (!detail) {
+      renderFailure(
+        new Error(
+          "Could not read the task terms, so the cost of releasing now is unknown. Retry, or re-run with --yes to release whatever it costs."
+        ),
+        { details: { code: "release_terms_unavailable" } }
+      );
+      return false;
+    }
+    const cost = detail.amounts.releaseCostNow;
+    if (!cost || BigInt(cost) <= 0n) return true;
+    renderFailure(
+      new Error(
+        `Releasing this claim now forfeits ${cost} base units of the stake. Review the terms, then re-run with --yes to accept the cost.`
+      ),
+      {
+        details: { code: "release_confirmation_required", releaseCostNow: cost, ...termsDetails }
+      }
+    );
+    return false;
+  }
+  renderFailure(
+    new Error(
+      `task ${name} cannot be undone. Review the terms, then re-run with --yes to confirm.`
+    ),
+    { details: { code: `${name}_confirmation_required`, ...termsDetails } }
+  );
+  return false;
+}
+function settlementActionCommand(spec) {
+  const command = new Command44(spec.name).description(spec.description).argument("<taskId>", "Task ID (0x-prefixed hex)");
+  if (spec.confirm === "release-cost") {
+    command.option("--yes", "Accept the stake forfeited by releasing now (releaseCostNow)");
+  } else if (spec.confirm === "always") {
+    command.option("--yes", "Confirm the action; it cannot be undone");
+  }
+  return command.action(async (taskId, opts) => {
+    try {
+      if (!await confirmSettlementAction(spec.name, spec.confirm, taskId, opts.yes)) return;
+      const keystore = await loadKeystore();
+      const expiresAt = settlementActionRequiresExpiry(spec.kind) ? settlementActionExpiresAt() : void 0;
+      const signature = await signMessage(
+        buildSettlementActionMessage(spec.kind, taskId, expiresAt),
+        keystore
+      );
+      const { data: result, idempotencyKey } = await apiPost(
+        `/api/tasks/${taskId}/${spec.kind}`,
+        {
+          taskId,
+          callerAddress: keystore.walletAddress,
+          signature,
+          ...expiresAt === void 0 ? {} : { expiresAt }
+        }
+      );
+      printResult(
+        { ...result, ...await settleRecording(result, idempotencyKey) },
+        { idempotencyKey }
+      );
+    } catch (err) {
+      renderFailure(err);
+    }
+  });
+}
+
+// src/commands/task/settlement-actions.ts
+var releaseCmd = settlementActionCommand({
+  name: "release",
+  kind: "release",
+  confirm: "release-cost",
+  description: "Hand a claim back before delivering (claim worker only). Free during the grace share of the claim time, then up to the full stake at expiry. Refuses without --yes when releaseCostNow is above zero."
+});
+var requestRevisionCmd = settlementActionCommand({
+  name: "request-revision",
+  kind: "request-revision",
+  description: "Send a delivery under review back to the worker for fixes (requester only, while revisions remain)"
+});
+var rejectCmd = settlementActionCommand({
+  name: "reject",
+  kind: "reject-delivery",
+  confirm: "always",
+  description: "Reject a delivery under review (requester only). The worker still receives the task's reject fee, and the task reopens or refunds per its reject outcome. This cannot be undone; requires --yes."
+});
+var settleCmd = settlementActionCommand({
+  name: "settle",
+  kind: "settle",
+  description: "Pay the worker for a delivery whose review window lapsed with no response (anyone may call)"
+});
+
 // src/commands/task/index.ts
-var taskCommand = new Command41("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(pitchesCmd);
-taskCommand.addCommand(selectWorkerCmd);
-taskCommand.addCommand(proofCmd);
-taskCommand.addCommand(proofsCmd);
-taskCommand.addCommand(bidCmd);
-taskCommand.addCommand(auctionAcceptCmd);
-taskCommand.addCommand(submissionsCmd);
-taskCommand.addCommand(selectWinnerCmd);
-taskCommand.addCommand(downloadCmd);
-taskCommand.addCommand(cancelCmd);
-taskCommand.addCommand(refundExpiredCmd);
-taskCommand.addCommand(rejectSubmissionCmd);
-taskCommand.addCommand(rejectAllSubmissionsCmd);
-taskCommand.addCommand(mySubmissionsCmd);
-taskCommand.addCommand(updateCmd);
-taskCommand.addCommand(forfeitCmd);
-taskCommand.addCommand(assignEvaluatorCmd);
-taskCommand.addCommand(evaluateCmd);
-taskCommand.addCommand(appealCmd);
-taskCommand.addCommand(evaluatorTimeoutCmd);
-taskCommand.addCommand(finalizeVerdictCmd);
-taskCommand.addCommand(resolveDisputeCmd);
-taskCommand.addCommand(unlockCmd);
-taskCommand.addCommand(inviteCmd);
-taskCommand.addCommand(uninviteCmd);
-taskCommand.addCommand(viewersCmd);
+var taskCommand2 = new Command45("task").description("Manage tasks");
+taskCommand2.addCommand(createCmd);
+taskCommand2.addCommand(listCmd);
+taskCommand2.addCommand(getCmd);
+taskCommand2.addCommand(submitCmd);
+taskCommand2.addCommand(acceptCmd);
+taskCommand2.addCommand(acceptSubmissionsCmd);
+taskCommand2.addCommand(rateCmd);
+taskCommand2.addCommand(claimCmd);
+taskCommand2.addCommand(pitchCmd);
+taskCommand2.addCommand(pitchesCmd);
+taskCommand2.addCommand(selectWorkerCmd);
+taskCommand2.addCommand(proofCmd);
+taskCommand2.addCommand(proofsCmd);
+taskCommand2.addCommand(bidCmd);
+taskCommand2.addCommand(auctionAcceptCmd);
+taskCommand2.addCommand(submissionsCmd);
+taskCommand2.addCommand(selectWinnerCmd);
+taskCommand2.addCommand(downloadCmd);
+taskCommand2.addCommand(cancelCmd);
+taskCommand2.addCommand(refundExpiredCmd);
+taskCommand2.addCommand(rejectSubmissionCmd);
+taskCommand2.addCommand(rejectAllSubmissionsCmd);
+taskCommand2.addCommand(mySubmissionsCmd);
+taskCommand2.addCommand(updateCmd);
+taskCommand2.addCommand(forfeitCmd);
+taskCommand2.addCommand(assignEvaluatorCmd);
+taskCommand2.addCommand(evaluateCmd);
+taskCommand2.addCommand(appealCmd);
+taskCommand2.addCommand(evaluatorTimeoutCmd);
+taskCommand2.addCommand(finalizeVerdictCmd);
+taskCommand2.addCommand(resolveDisputeCmd);
+taskCommand2.addCommand(unlockCmd);
+taskCommand2.addCommand(inviteCmd);
+taskCommand2.addCommand(uninviteCmd);
+taskCommand2.addCommand(viewersCmd);
+taskCommand2.addCommand(termsCmd);
+taskCommand2.addCommand(releaseCmd);
+taskCommand2.addCommand(requestRevisionCmd);
+taskCommand2.addCommand(rejectCmd);
+taskCommand2.addCommand(settleCmd);
+taskCommand2.addCommand(reviewCmd);
+taskCommand2.addCommand(startReviewCmd);
 
 // src/commands/agent/index.ts
-import { Command as Command44, Option as Option2 } from "commander";
+import { Command as Command48, Option as Option3 } from "commander";
 
 // src/commands/agent/credits.ts
-import { Command as Command42 } from "commander";
+import { Command as Command46 } from "commander";
 
 // src/lib/tty-confirm.ts
 import { createInterface as createInterface2 } from "readline";
@@ -2397,7 +3187,7 @@ function setupLines(plan, pricing) {
     ...rateLines(pricing)
   ];
 }
-var setupCommand = new Command42("setup").description(
+var setupCommand = new Command46("setup").description(
   "Approve the compute allocation that pays for sandboxes: daily and monthly caps, and optional auto-top-up"
 ).requiredOption("--per-day <usd>", "Most compute credit bought in one UTC day, in USD").requiredOption("--per-month <usd>", "Most compute credit bought in one UTC month, in USD").option("--total <usd>", "Most this allocation ever buys, in USD (default: 12 months)").option(
   "--auto-top-up-below <credits>",
@@ -2434,7 +3224,7 @@ var setupCommand = new Command42("setup").description(
     printResult({ config, caps: plan.caps, autoTopUp: plan.autoTopUp ?? null });
   }
 );
-var buyCommand = new Command42("buy").description("Buy compute credit over x402 from the compute allocation, after showing the rate").option("--amount <usd>", "Purchase size in whole USD (see `credits status` for the sizes)").option("--yes", "Skip the confirmation prompt (the allocation caps still apply)").action(async (options) => {
+var buyCommand = new Command46("buy").description("Buy compute credit over x402 from the compute allocation, after showing the rate").option("--amount <usd>", "Purchase size in whole USD (see `credits status` for the sizes)").option("--yes", "Skip the confirmation prompt (the allocation caps still apply)").action(async (options) => {
   const config = await loadComputeCreditConfig();
   if (!config) {
     throw new ComputeCreditError(
@@ -2464,17 +3254,17 @@ var buyCommand = new Command42("buy").description("Buy compute credit over x402
     rate: { rateCardVersion: pricing.rateCardVersion, usdPerCredit: pricing.usdPerCredit }
   });
 });
-var statusCommand2 = new Command42("status").description(
+var statusCommand2 = new Command46("status").description(
   "Show compute credit balance, rate, recent debits and purchases, and the caps; an approved auto-top-up runs when the balance is below its threshold"
 ).action(async () => {
   printResult(await computeCreditStatus());
 });
-var checkCommand = new Command42("check").description(
+var checkCommand = new Command46("check").description(
   "Check the compute credit balance and, when auto-top-up was approved and the balance is low, buy one chunk"
 ).action(async () => {
   printResult(await checkComputeBalance());
 });
-var reconcileCommand = new Command42("reconcile").description(
+var reconcileCommand = new Command46("reconcile").description(
   "Settle purchases whose outcome was lost, by their idempotency key; never pays again"
 ).option(
   "--release <key>",
@@ -2521,10 +3311,10 @@ var reconcileCommand = new Command42("reconcile").description(
     ...recoveryError === void 0 ? {} : { recoveryError }
   });
 });
-var disableAutoTopUpCommand = new Command42("disable-auto-top-up").description("Turn off auto-top-up and close its allocation").action(async () => {
+var disableAutoTopUpCommand = new Command46("disable-auto-top-up").description("Turn off auto-top-up and close its allocation").action(async () => {
   printResult({ config: await disableComputeAutoTopUp() });
 });
-var agentCreditsCommand = new Command42("credits").description("Prepaid compute credit for agent sandboxes, bought over x402").addCommand(setupCommand).addCommand(buyCommand).addCommand(statusCommand2).addCommand(checkCommand).addCommand(reconcileCommand).addCommand(disableAutoTopUpCommand);
+var agentCreditsCommand = new Command46("credits").description("Prepaid compute credit for agent sandboxes, bought over x402").addCommand(setupCommand).addCommand(buyCommand).addCommand(statusCommand2).addCommand(checkCommand).addCommand(reconcileCommand).addCommand(disableAutoTopUpCommand);
 
 // src/commands/agent/launch.ts
 var EXPERIMENTAL_AGENT_ENV = "TASKMARKET_EXPERIMENTAL_AGENT";
@@ -2546,8 +3336,13 @@ async function runAgentCommand(options) {
   try {
     const { assertAgentCompatibility } = await import("./compatibility-KUYGZSUC.js");
     const pi = assertAgentCompatibility();
-    const { runAgent } = await import("./launch-2U3KFTFD.js");
-    result = await runAgent({ model: options.model, pi });
+    const { runAgent } = await import("./launch-C5HUFUU2.js");
+    result = await runAgent({
+      model: options.model,
+      pi,
+      sync: options.sync,
+      includeSecret: options.includeSecret
+    });
   } catch (error) {
     renderFailure(error, {
       details: error instanceof AgentLaunchError ? { ...error.details, code: error.code } : void 0
@@ -2572,7 +3367,7 @@ async function runAgentCommand(options) {
 }
 
 // src/commands/agent/manage.ts
-import { Command as Command43 } from "commander";
+import { Command as Command47 } from "commander";
 async function run(options, work, lines) {
   try {
     const value = await work();
@@ -2597,37 +3392,76 @@ async function requireExperimental() {
   );
 }
 function agentManagementCommands() {
-  const status = new Command43("status").description(
+  const status = new Command47("status").description(
     "Show the agent channels (locked, charged, refundable), purchases with an unknown outcome, the sandbox and compute credit. Reads only."
   ).option("--json", "Print the versioned JSON envelope").action(async (options) => {
-    const { collectAgentStatus, statusLines } = await import("./status-5IMULBQQ.js");
+    const { collectAgentStatus, statusLines } = await import("./status-SDLSTJIA.js");
     await run(options, () => collectAgentStatus(), statusLines);
   });
-  const doctor = new Command43("doctor").description(
+  const doctor = new Command47("doctor").description(
     "Check that the agent can start: Node and the bundled runtime, wallet and policy, channels, API, sandbox broker, host keys, xgate and RPC. Reads only."
   ).option("--json", "Print the versioned JSON envelope").action(async (options) => {
-    const { runDoctor, doctorLines } = await import("./doctor-7TWLIJWW.js");
+    const { runDoctor, doctorLines } = await import("./doctor-5FUGI42V.js");
     const report = await run(options, () => runDoctor(), doctorLines);
     if (report && !report.ok) process.exitCode = 1;
   });
-  const reconcile = new Command43("reconcile").description(
-    "Decide an agent purchase whose outcome is unknown, by its invocation ID. Never sends it again."
-  ).argument("<invocation-id>", "The purchase, as status or the agent named it").option("--json", "Print the versioned JSON envelope").action(async (invocationId, options) => {
-    const { reconcileInvocation } = await import("./reconcile-XZR2UYSW.js");
-    await run(
-      options,
-      () => reconcileInvocation(invocationId),
-      (view) => [`Purchase ${view.invocationId} on ${view.rail}: ${view.outcome}`, view.message]
-    );
-  });
-  const topup = new Command43("topup").description(
+  const reconcile = new Command47("reconcile").description(
+    "Decide an agent purchase whose outcome is unknown, by its invocation ID; or, with --channel or --rail, everything one channel still has open. Never sends anything again."
+  ).argument("[invocation-id]", "The purchase, as status or the agent named it").option("--rail <id>", "Reconcile the open purchases of this rail's channel").option(
+    "--channel <channel-id>",
+    "Reconcile the open purchases of this channel, as status lists it; also reaches retired channels"
+  ).option("--json", "Print the versioned JSON envelope").action(
+    async (invocationId, options) => {
+      const { reconcileChannelPurchases, reconcileInvocation } = await import("./reconcile-Q7XFHDQQ.js");
+      const choice = { rail: options.rail, channel: options.channel };
+      if (invocationId !== void 0) {
+        await run(
+          options,
+          () => reconcileInvocation(invocationId, { choice }),
+          (view) => [
+            `Purchase ${view.invocationId} on ${view.rail}: ${view.outcome}`,
+            view.message,
+            ...view.releasedFrom.map(
+              (rail) => `Released the lease it had left on the ${rail} channel.`
+            )
+          ]
+        );
+        return;
+      }
+      await run(
+        options,
+        async () => {
+          if (options.rail === void 0 && options.channel === void 0) {
+            const { AgentLaunchError } = await import("./errors-2L357HGA.js");
+            throw new AgentLaunchError(
+              "invalid_invocation_id",
+              "Name a purchase (taskmarket agent reconcile <invocation-id>) or a channel (--channel <id> or --rail <id>)"
+            );
+          }
+          return reconcileChannelPurchases(choice);
+        },
+        (view) => [
+          `Channel ${view.channelId} (${view.rail}${view.retired ? ", retired" : ""})`,
+          ...view.purchases.map(
+            (p) => p.outcome === "failed" ? `  ${p.invocationId}: not reconciled (${p.code}): ${p.message}` : `  ${p.invocationId}: ${p.outcome}. ${p.message}`
+          ),
+          ...view.releasedLease ? [
+            `Released the lease another channel's purchase ${view.releasedLease} had left on it.`
+          ] : [],
+          view.message,
+          ...channelLines(view.channel)
+        ]
+      );
+    }
+  );
+  const topup = new Command47("topup").description(
     "Check a channel top-up against the approved budget: within it, the channel deposits by itself with the next turn that needs funds; over it, a new approval is needed"
   ).requiredOption("--amount <usdc>", "Top-up in USDC, e.g. 5 or 2.50").option("--rail <id>", "The rail to top up (required when the policy has more than one)").option("--json", "Print the versioned JSON envelope").action(async (options) => {
     await run(
       options,
       async () => {
         await requireExperimental();
-        const { usdcToAtomic, AGENT_VIEW_VERSION } = await import("./budget-view-XKZC3GY5.js");
+        const { usdcToAtomic, AGENT_VIEW_VERSION } = await import("./budget-view-JPZ7HWR2.js");
         const { AgentLaunchError } = await import("./errors-2L357HGA.js");
         const amount = usdcToAtomic(options.amount);
         if (amount === void 0 || amount === "0") {
@@ -2636,7 +3470,7 @@ function agentManagementCommands() {
             `Not a USDC amount: ${options.amount} (digits, at most 6 decimals)`
           );
         }
-        const { openAgentChannels, requestTopUp, selectRail, withdrawalHatch } = await import("./channels-JF4Q5KG3.js");
+        const { openAgentChannels, requestTopUp, selectRail, withdrawalHatch } = await import("./channels-544VRSKF.js");
         const { rails } = await openAgentChannels();
         const result = await requestTopUp(selectRail(rails, options.rail), amount);
         return {
@@ -2649,7 +3483,7 @@ function agentManagementCommands() {
       (view) => [view.note, ...channelLines(view.channel)]
     );
   });
-  const close = new Command43("close").description(
+  const close = new Command47("close").description(
     "Close the agent's channel and refund its unused balance cooperatively; checks an earlier close instead of sending it again"
   ).option("--rail <id>", "The rail to close (required when the policy has more than one)").option(
     "--channel <channel-id>",
@@ -2659,9 +3493,11 @@ function agentManagementCommands() {
       options,
       async () => {
         await requireExperimental();
-        const { AGENT_VIEW_VERSION } = await import("./budget-view-XKZC3GY5.js");
-        const { closeChannel, openAgentChannels, selectChannel } = await import("./channels-JF4Q5KG3.js");
-        const { rail, retired } = selectChannel(await openAgentChannels(), options);
+        const { AGENT_VIEW_VERSION } = await import("./budget-view-JPZ7HWR2.js");
+        const { closeChannel, openAgentChannels, selectChannel } = await import("./channels-544VRSKF.js");
+        const { reconcileLeasedPurchase } = await import("./reconcile-Q7XFHDQQ.js");
+        const opened = await openAgentChannels();
+        const { rail, retired } = selectChannel(opened, options);
         const result = await closeChannel(
           rail,
           async (lines) => {
@@ -2672,7 +3508,16 @@ function agentManagementCommands() {
             }
             return confirmAtTerminal(lines, "pass --yes to close without a prompt");
           },
-          { retired }
+          {
+            retired,
+            reconcilePurchase: (id) => reconcileLeasedPurchase(opened, id),
+            wait: {
+              onWait: (progress2) => process.stderr.write(
+                `Refund ${progress2.transaction} sent; waiting for it to confirm on chain (${Math.round(progress2.waitedMs / 1e3)} s of up to ${Math.round(progress2.timeoutMs / 1e3)} s)
+`
+              )
+            }
+          }
         );
         return {
           version: AGENT_VIEW_VERSION,
@@ -2683,7 +3528,7 @@ function agentManagementCommands() {
       (view) => [
         {
           refunded: `Closed: the unused balance of ${view.rail} was refunded to the wallet.`,
-          pending: `The refund of ${view.rail} is not confirmed yet${view.reconciled ? "" : " (sent)"}. Run close again to check it; it is never sent twice.`,
+          pending: view.operation?.transaction ? `The refund of ${view.rail} was sent (transaction ${view.operation.transaction}) and is still confirming on chain. Run taskmarket agent close again in a minute to record it; it is never sent twice.` : `The refund of ${view.rail} may have been sent, and its outcome is not known yet. Run taskmarket agent close again later to check it; it is never sent twice.`,
           failed: `The router refused the refund of ${view.rail}; nothing was returned.`,
           closed: `The ${view.rail} channel is already closed.`
         }[view.outcome],
@@ -2696,22 +3541,85 @@ function agentManagementCommands() {
       ]
     );
   });
-  return [status, doctor, reconcile, topup, close];
+  const pull = new Command47("pull").description(
+    "After a session: review the changes the agent left in its sandbox (saved when the session ended; the sandbox is not resumed) and apply them to this project on approval. Conflicts with your local edits and host configuration are listed, never applied. Inside a session use /pull."
+  ).option("--diff", "Print the full diff").option("--apply", "Apply the clean changes without asking").option(
+    "--overwrite <path>",
+    "Overwrite this conflicting file with the sandbox version (repeatable)",
+    (value, previous = []) => [...previous, value]
+  ).option(
+    "--keep-local <path>",
+    "Resolve this saved change by keeping the file as it is in this project (repeatable)",
+    (value, previous = []) => [...previous, value]
+  ).option(
+    "--recover",
+    "After a failed or interrupted end-of-session save: reconnect to the sandbox the session left running, save its changes here, then stop it"
+  ).option(
+    "--discard",
+    "Drop the saved changes (or the record of a failed save) instead of pulling them"
+  ).option(
+    "--force-unclaim",
+    "Release the project from a session or pull that is not running but still holds it (refused while it is)"
+  ).option("--yes", "With --discard or --force-unclaim: skip the confirmation prompt").option("--json", "Print the versioned JSON envelope").action(
+    async (options) => {
+      await run(
+        options,
+        async () => {
+          await requireExperimental();
+          const { runPull } = await import("./sync-pull-TKM4EDGH.js");
+          const { terminalPrompter } = await import("./prompter-LSICEYSQ.js");
+          return runPull(options, {
+            interactive: Boolean(process.stdin.isTTY && process.stdout.isTTY) && !options.json,
+            prompter: () => terminalPrompter(),
+            say: (lines) => {
+              if (!options.json && lines.length > 0)
+                process.stdout.write(`${lines.join("\n")}
+`);
+            }
+          });
+        },
+        (view) => {
+          const lines = [];
+          for (const skip of view.skipped) {
+            lines.push(`  not applied: ${skip.path} (${skip.reason.replace(/_/g, " ")})`);
+          }
+          lines.push(view.note);
+          return lines;
+        }
+      );
+    }
+  );
+  return [status, doctor, reconcile, topup, close, pull];
 }
 
 // src/commands/agent/index.ts
 var experimental = agentCommandEnabled();
-var agentCommand = new Command44("agent").description(
+var agentCommand = new Command48("agent").description(
   experimental ? "The Taskmarket agent and the compute it runs on. Without a subcommand (experimental), open Pi's interactive coding agent in this project, with paid xgate inference from your wallet and tools in your cloud sandbox" : "The Taskmarket agent and the compute it runs on"
 ).addOption(
-  new Option2("--model <id>", "Start on one model from your approved spending policy").hideHelp(
+  new Option3("--model <id>", "Start on one model from your approved spending policy").hideHelp(
     !experimental
   )
+).addOption(
+  new Option3(
+    "--sync",
+    "Upload this project to the sandbox for this session without asking (what goes up is still shown); needed without a terminal until you approve the project once"
+  ).hideHelp(!experimental)
+).addOption(
+  new Option3(
+    "--no-sync",
+    "Start with an empty sandbox: upload nothing from this project"
+  ).hideHelp(!experimental)
+).addOption(
+  new Option3(
+    "--include-secret <path>",
+    "Upload this secret-like file too (a path in the project, not a pattern; repeatable)"
+  ).argParser((value, previous = []) => [...previous, value]).hideHelp(!experimental)
 ).allowExcessArguments(false).action(runAgentCommand);
 if (experimental) {
   agentCommand.addHelpText(
     "after",
-    "\nThe session offers only models your spending policy approves and xgate qualifies. Pi runs\non this machine with its configuration under TASKMARKET_HOME; every tool runs in a sandbox."
+    "\nThe session offers only models your spending policy approves and xgate qualifies. Pi runs\non this machine with its configuration under TASKMARKET_HOME; every tool runs in a sandbox.\nThe project is uploaded with your approval (asked once per project); secret-like files stay\nhere unless you name them. /pull in the session, or taskmarket agent pull after it, shows\nwhat the agent changed and applies it only when you approve; /sync sends your local edits."
   );
 }
 agentCommand.addCommand(agentCreditsCommand);
@@ -2720,8 +3628,8 @@ for (const command of agentManagementCommands()) {
 }
 
 // src/commands/agents.ts
-import { Command as Command45 } from "commander";
-var agentsCommand = new Command45("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 Command49 } from "commander";
+var agentsCommand = new Command49("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);
@@ -2732,8 +3640,8 @@ var agentsCommand = new Command45("agents").description("Browse the agent direct
 });
 
 // src/commands/inbox.ts
-import { Command as Command46 } from "commander";
-var inboxCommand = new Command46("inbox").description("Show tasks you created and tasks you are working on").action(async () => {
+import { Command as Command50 } from "commander";
+var inboxCommand = new Command50("inbox").description("Show tasks you created and tasks you are working on").action(async () => {
   const auth = await signReadAuth();
   if (!auth) {
     printError("No keystore found. Run `taskmarket init` first.");
@@ -2754,8 +3662,8 @@ var inboxCommand = new Command46("inbox").description("Show tasks you created an
 });
 
 // src/commands/actions.ts
-import { Command as Command47 } from "commander";
-var actionsCommand = new Command47("actions").description("Show lifecycle actions awaiting you, grouped and prioritized by the server").action(async () => {
+import { Command as Command51 } from "commander";
+var actionsCommand = new Command51("actions").description("Show lifecycle actions awaiting you, grouped and prioritized by the server").action(async () => {
   const auth = await signReadAuth();
   if (!auth) {
     printError("No keystore found. Run `taskmarket init` first.");
@@ -2769,8 +3677,8 @@ var actionsCommand = new Command47("actions").description("Show lifecycle action
 });
 
 // src/commands/deposit.ts
-import { Command as Command48 } from "commander";
-var depositCommand = new Command48("deposit").description("Show wallet address and network info for funding").action(async () => {
+import { Command as Command52 } from "commander";
+var depositCommand = new Command52("deposit").description("Show wallet address and network info for funding").action(async () => {
   let address;
   try {
     address = await getWalletAddress();
@@ -2802,11 +3710,11 @@ var depositCommand = new Command48("deposit").description("Show wallet address a
 });
 
 // src/commands/wallet/index.ts
-import { Command as Command57 } from "commander";
+import { Command as Command63 } from "commander";
 
 // src/commands/wallet/balance.ts
-import { Command as Command49 } from "commander";
-var walletBalanceCommand = new Command49("balance").description("Show the wallet's payment-token balance on the selected network").option("--address <addr>", "Address to check (defaults to own wallet)").action(async (opts) => {
+import { Command as Command53 } from "commander";
+var walletBalanceCommand = new Command53("balance").description("Show the wallet's payment-token balance on the selected network").option("--address <addr>", "Address to check (defaults to own wallet)").action(async (opts) => {
   let address = opts.address;
   if (!address) {
     const keystore = await loadKeystore();
@@ -2819,7 +3727,7 @@ var walletBalanceCommand = new Command49("balance").description("Show the wallet
 });
 
 // src/commands/wallet/import.ts
-import { Command as Command50 } from "commander";
+import { Command as Command54 } from "commander";
 import { createInterface as createInterface3 } from "readline";
 import { privateKeyToAccount as privateKeyToAccount2 } from "viem/accounts";
 function normalizePrivateKey(raw) {
@@ -2854,7 +3762,7 @@ function promptHiddenInput(prompt) {
     });
   });
 }
-var walletImportCommand = new Command50("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)").option(
+var walletImportCommand = new Command54("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)").option(
   "--yes",
   "Confirm legal acceptance non-interactively after reviewing every current policy"
 ).action(async (opts) => {
@@ -2934,11 +3842,57 @@ var walletImportCommand = new Command50("import").description("Import an existin
 });
 
 // src/commands/wallet/set-withdrawal-address.ts
-import { Command as Command51 } from "commander";
+import { randomBytes as randomBytes2 } from "crypto";
+import { Command as Command55 } from "commander";
+
+// src/lib/withdrawal-pin.ts
+var WithdrawalAddressMismatchError = class extends Error {
+  constructor(pinned, server) {
+    super(
+      `Refusing to sign: the server reports withdrawal address ${server}, but this CLI has ${pinned} pinned locally. Nothing was signed or sent. If you changed the withdrawal address yourself (for example on the web with your account recovery code), accept the new address with: taskmarket wallet sync-withdrawal-address`
+    );
+    this.pinned = pinned;
+    this.server = server;
+    this.name = "WithdrawalAddressMismatchError";
+  }
+};
+async function pinWithdrawalAddress(keystore, address) {
+  await saveKeystore({ ...keystore, withdrawalAddress: address });
+}
+async function verifyWithdrawalAddress(keystore, serverAddress, log = (line) => process.stderr.write(line + "\n")) {
+  const pinned = keystore.withdrawalAddress;
+  if (!pinned) {
+    await pinWithdrawalAddress(keystore, serverAddress);
+    log(`Note: pinned withdrawal address ${serverAddress} in the local keystore.`);
+    return serverAddress;
+  }
+  if (pinned.toLowerCase() !== serverAddress.toLowerCase()) {
+    throw new WithdrawalAddressMismatchError(pinned, serverAddress);
+  }
+  return pinned;
+}
+function paymentTokenDomain(chainId) {
+  const { payment } = taskmarketChain(chainId);
+  const verifyingContract = payment.token ?? (chainId === 31337 ? process.env.USDC_TOKEN_ADDRESS : void 0);
+  if (!verifyingContract) {
+    throw new Error(
+      `Chain ${chainId} has no known payment token address` + (chainId === 31337 ? "; set USDC_TOKEN_ADDRESS to the local mock token" : "")
+    );
+  }
+  return {
+    name: payment.domain.name,
+    version: payment.domain.version,
+    chainId,
+    verifyingContract
+  };
+}
+
+// src/commands/wallet/set-withdrawal-address.ts
+var SIGNATURE_TTL_SECONDS = 5 * 60;
 function isValidAddress(addr) {
   return /^0x[a-fA-F0-9]{40}$/.test(addr);
 }
-var setWithdrawalAddressCommand = new Command51("set-withdrawal-address").description("Set a withdrawal address for payment-token withdrawals (one-time, free)").argument("<address>", "Ethereum address to receive withdrawals").action(async (address) => {
+var setWithdrawalAddressCommand = new Command55("set-withdrawal-address").description("Set a withdrawal address for payment-token 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");
     return;
@@ -2951,13 +3905,26 @@ var setWithdrawalAddressCommand = new Command51("set-withdrawal-address").descri
     return;
   }
   const walletAddress = keystore.walletAddress;
-  const message = buildSetWithdrawalAddressMessage(address);
+  const chainId = selectedNetwork().chainId;
+  const nonce = `0x${randomBytes2(32).toString("hex")}`;
+  const expiresAt = Math.floor(Date.now() / 1e3) + SIGNATURE_TTL_SECONDS;
+  const message = buildSetWithdrawalAddressMessage({
+    walletAddress,
+    withdrawalAddress: address,
+    chainId,
+    nonce,
+    expiresAt
+  });
   const signature = await signMessage(message, keystore);
   const { data: result, idempotencyKey } = await apiPost("/api/wallet/set-withdrawal-address", {
     walletAddress,
     withdrawalAddress: address,
-    signature
+    signature,
+    nonce,
+    expiresAt,
+    chainId
   });
+  await pinWithdrawalAddress(keystore, result.withdrawalAddress);
   printResult(
     {
       withdrawalAddress: result.withdrawalAddress,
@@ -2969,8 +3936,8 @@ var setWithdrawalAddressCommand = new Command51("set-withdrawal-address").descri
 });
 
 // src/commands/wallet/get-withdrawal-address.ts
-import { Command as Command52 } from "commander";
-var getWithdrawalAddressCommand = new Command52("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) => {
+import { Command as Command56 } from "commander";
+var getWithdrawalAddressCommand = new Command56("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 address = opts.address;
   if (!address) {
     const keystore = await loadKeystore();
@@ -2981,14 +3948,14 @@ var getWithdrawalAddressCommand = new Command52("get-withdrawal-address").descri
 });
 
 // src/commands/wallet/change-withdrawal-address.ts
-import { Command as Command53 } from "commander";
+import { Command as Command57 } from "commander";
 function isValidAddress2(addr) {
   return /^0x[a-fA-F0-9]{40}$/.test(addr);
 }
 function isValidRecoveryCode(code) {
   return /^\d{8}$/.test(code);
 }
-var changeWithdrawalAddressCommand = new Command53("change-withdrawal-address").description("Change the withdrawal address using the account recovery code (RFC-0012)").argument("<recovery-code>", "The 8-digit account recovery code from set-withdrawal-address").argument("<new-address>", "New Ethereum address to receive withdrawals").action(async (recoveryCode, newAddress) => {
+var changeWithdrawalAddressCommand = new Command57("change-withdrawal-address").description("Change the withdrawal address using the account recovery code (RFC-0012)").argument("<recovery-code>", "The 8-digit account recovery code from set-withdrawal-address").argument("<new-address>", "New Ethereum address to receive withdrawals").action(async (recoveryCode, newAddress) => {
   if (!isValidRecoveryCode(recoveryCode)) {
     printError("Invalid account recovery code: must be 8 digits");
     return;
@@ -3009,6 +3976,7 @@ var changeWithdrawalAddressCommand = new Command53("change-withdrawal-address").
     accountRecoveryCode: recoveryCode,
     newWithdrawalAddress: newAddress
   });
+  await pinWithdrawalAddress(keystore, result.withdrawalAddress);
   printResult(
     {
       withdrawalAddress: result.withdrawalAddress,
@@ -3019,9 +3987,39 @@ var changeWithdrawalAddressCommand = new Command53("change-withdrawal-address").
   );
 });
 
+// src/commands/wallet/sync-withdrawal-address.ts
+import { Command as Command58 } from "commander";
+var syncWithdrawalAddressCommand = new Command58("sync-withdrawal-address").description(
+  "Accept the withdrawal address registered on the server as the locally pinned one (after a change made elsewhere, e.g. on the web)"
+).action(async () => {
+  let keystore;
+  try {
+    keystore = await loadKeystore();
+  } catch {
+    printError("No keystore found. Run `taskmarket init` first.");
+    return;
+  }
+  const { withdrawalAddress } = await apiGet(
+    `/api/wallet/withdrawal-address?address=${keystore.walletAddress}`
+  );
+  if (!withdrawalAddress) {
+    printError(
+      "No withdrawal address set. Run: taskmarket wallet set-withdrawal-address <address>"
+    );
+    return;
+  }
+  const previous = keystore.withdrawalAddress ?? null;
+  await pinWithdrawalAddress(keystore, withdrawalAddress);
+  printResult({
+    previousWithdrawalAddress: previous,
+    withdrawalAddress,
+    changed: previous === null || previous.toLowerCase() !== withdrawalAddress.toLowerCase()
+  });
+});
+
 // src/commands/wallet/reveal-recovery-code.ts
-import { Command as Command54 } from "commander";
-var revealRecoveryCodeCommand = new Command54("reveal-recovery-code").description("One-time reveal of your account recovery code, if one has not been generated yet").action(async () => {
+import { Command as Command59 } from "commander";
+var revealRecoveryCodeCommand = new Command59("reveal-recovery-code").description("One-time reveal of your account recovery code, if one has not been generated yet").action(async () => {
   let keystore;
   try {
     keystore = await loadKeystore();
@@ -3046,8 +4044,8 @@ var revealRecoveryCodeCommand = new Command54("reveal-recovery-code").descriptio
 });
 
 // src/commands/wallet/publish-key.ts
-import { Command as Command55 } from "commander";
-var publishKeyCommand = new Command55("publish-key").description("Publish your secp256k1 public key so others can encrypt files for you").action(async () => {
+import { Command as Command60 } from "commander";
+var publishKeyCommand = new Command60("publish-key").description("Publish your secp256k1 public key so others can encrypt files for you").action(async () => {
   let keystore;
   try {
     keystore = await loadKeystore();
@@ -3067,13 +4065,13 @@ var publishKeyCommand = new Command55("publish-key").description("Publish your s
 });
 
 // src/commands/wallet/withdraw-dreams.ts
-import { Command as Command56 } from "commander";
+import { Command as Command61 } from "commander";
 import { toHex } from "viem";
 var AUTHORIZATION_VALIDITY_SECONDS = 300;
 function isValidAddress3(addr) {
   return /^0x[a-fA-F0-9]{40}$/.test(addr);
 }
-var withdrawDreamsCommand = new Command56("withdraw-dreams").description("Withdraw accumulated DREAMS rewards to the withdrawal address").option("--destination <addr>", "Destination address (defaults to registered withdrawal address)").action(async (opts) => {
+var withdrawDreamsCommand = new Command61("withdraw-dreams").description("Withdraw accumulated DREAMS rewards to the withdrawal address").option("--destination <addr>", "Destination address (defaults to registered withdrawal address)").action(async (opts) => {
   let keystore;
   try {
     keystore = await loadKeystore();
@@ -3097,7 +4095,12 @@ var withdrawDreamsCommand = new Command56("withdraw-dreams").description("Withdr
       );
       return;
     }
-    destination = addressResponse.withdrawalAddress;
+    try {
+      destination = await verifyWithdrawalAddress(keystore, addressResponse.withdrawalAddress);
+    } catch (err) {
+      renderFailure(err);
+      return;
+    }
   }
   const nonce = toHex(crypto.getRandomValues(new Uint8Array(32)));
   const validBefore = String(Math.floor(Date.now() / 1e3) + AUTHORIZATION_VALIDITY_SECONDS);
@@ -3126,20 +4129,196 @@ var withdrawDreamsCommand = new Command56("withdraw-dreams").description("Withdr
   );
 });
 
+// src/commands/wallet/bridge.ts
+import { Command as Command62 } from "commander";
+import { toHex as toHex2 } from "viem";
+var USDC_TYPES = {
+  TransferWithAuthorization: [
+    { name: "from", type: "address" },
+    { name: "to", type: "address" },
+    { name: "value", type: "uint256" },
+    { name: "validAfter", type: "uint256" },
+    { name: "validBefore", type: "uint256" },
+    { name: "nonce", type: "bytes32" }
+  ]
+};
+var bridgeTiming = { intervalMs: 3e3, timeoutMs: 10 * 6e4 };
+function progress(message) {
+  process.stderr.write(`${message}
+`);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function sameAddress(a, b) {
+  return a.toLowerCase() === b.toLowerCase();
+}
+async function pollBridgeStatus(requestId) {
+  const deadline = Date.now() + bridgeTiming.timeoutMs;
+  let last;
+  for (; ; ) {
+    let status = null;
+    try {
+      status = await apiGet(
+        `/api/wallet/bridge-status?requestId=${encodeURIComponent(requestId)}`
+      );
+    } catch (err) {
+      progress(`Could not read bridge status: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    if (status) {
+      if (status.status !== last) progress(`Bridge status: ${status.status}`);
+      last = status.status;
+      if (isTerminalWalletBridgeStatus(status.status)) return status;
+    }
+    if (Date.now() >= deadline) return status;
+    await sleep(bridgeTiming.intervalMs);
+  }
+}
+var walletBridgeCommand = new Command62("bridge").description(
+  "Move free USDC on Base to OUSD at the same address on Tempo (gasless, through Relay)"
+).requiredOption("--to <chain>", 'Destination chain (only "tempo")').argument("<amount>", "Amount of USDC in whole tokens (minimum 1, e.g. 25)").action(async (amount, opts) => {
+  if (opts.to !== "tempo") {
+    printError('Invalid --to: the only bridge destination is "tempo"');
+    return;
+  }
+  if (!/^\d+(\.\d{1,6})?$/.test(amount) || Number(amount) <= 0) {
+    printError("Invalid amount: must be a positive number with at most 6 decimals (e.g. 25)");
+    return;
+  }
+  const [whole, fraction = ""] = amount.split(".");
+  const amountBaseUnits = (BigInt(whole) * 1000000n + BigInt(fraction.padEnd(6, "0"))).toString();
+  let keystore;
+  try {
+    keystore = await loadKeystore();
+  } catch {
+    printError("No keystore found. Run `taskmarket init` first.");
+    return;
+  }
+  const from = keystore.walletAddress;
+  let quote;
+  try {
+    ({ data: quote } = await apiPost("/api/wallet/bridge-quote", {
+      chainId: WALLET_BRIDGE_ORIGIN_CHAIN_ID,
+      from,
+      to: "tempo",
+      amountBaseUnits
+    }));
+  } catch (err) {
+    renderFailure(err);
+    return;
+  }
+  if (!sameAddress(quote.recipient, from) || !sameAddress(quote.refundTo, from) || !sameAddress(quote.authorization.message.to, quote.depositAddress) || quote.amountBaseUnits !== amountBaseUnits || quote.authorization.message.value !== amountBaseUnits || quote.destinationChainId !== WALLET_BRIDGE_TEMPO_CHAIN_ID) {
+    printError("The bridge quote does not match this request; nothing was signed");
+    return;
+  }
+  let domain;
+  try {
+    domain = paymentTokenDomain(WALLET_BRIDGE_ORIGIN_CHAIN_ID);
+  } catch (err) {
+    renderFailure(err);
+    return;
+  }
+  progress(
+    `Bridging ${formatPaymentAmount(amountBaseUnits, WALLET_BRIDGE_ORIGIN_CHAIN_ID)}: expect ${formatPaymentAmount(quote.expectedOutBaseUnits, WALLET_BRIDGE_TEMPO_CHAIN_ID)}, at least ${formatPaymentAmount(quote.minimumOutBaseUnits, WALLET_BRIDGE_TEMPO_CHAIN_ID)} (Relay fee ${quote.fees.relayerUsd} USD)`
+  );
+  const authorization = {
+    from,
+    to: quote.depositAddress,
+    value: amountBaseUnits,
+    validAfter: quote.authorization.message.validAfter,
+    validBefore: quote.authorization.message.validBefore,
+    nonce: toHex2(crypto.getRandomValues(new Uint8Array(32)))
+  };
+  const signature = await signTypedData(
+    {
+      domain,
+      types: USDC_TYPES,
+      primaryType: "TransferWithAuthorization",
+      message: authorization
+    },
+    keystore
+  );
+  let bridged;
+  let idempotencyKey;
+  try {
+    ({ data: bridged, idempotencyKey } = await apiPost("/api/wallet/bridge", {
+      chainId: WALLET_BRIDGE_ORIGIN_CHAIN_ID,
+      from,
+      amountBaseUnits,
+      authorization,
+      signature
+    }));
+  } catch (err) {
+    renderFailure(err);
+    return;
+  }
+  progress(`Deposited on Base: ${bridged.txHash}. Waiting for Relay to fill on Tempo...`);
+  const status = await pollBridgeStatus(bridged.requestId);
+  const tempoExplorer = taskmarketChain(WALLET_BRIDGE_TEMPO_CHAIN_ID).explorerUrl;
+  const baseExplorer = taskmarketChain(WALLET_BRIDGE_ORIGIN_CHAIN_ID).explorerUrl;
+  const output = {
+    status: status?.status ?? "unknown",
+    requestId: bridged.requestId,
+    from,
+    recipient: bridged.recipient,
+    amountBaseUnits,
+    amount: formatPaymentAmount(amountBaseUnits, WALLET_BRIDGE_ORIGIN_CHAIN_ID),
+    expectedOut: formatPaymentAmount(quote.expectedOutBaseUnits, WALLET_BRIDGE_TEMPO_CHAIN_ID),
+    minimumOut: formatPaymentAmount(quote.minimumOutBaseUnits, WALLET_BRIDGE_TEMPO_CHAIN_ID),
+    tokenSymbol: "OUSD",
+    depositTxHash: bridged.txHash,
+    depositExplorerUrl: `${baseExplorer}/tx/${bridged.txHash}`
+  };
+  if (status?.status === "success") {
+    const fillTxHash = status.txHashes[0];
+    printResult(
+      {
+        ...output,
+        fillTxHash: fillTxHash ?? null,
+        explorerUrl: fillTxHash ? `${tempoExplorer}/tx/${fillTxHash}` : `${tempoExplorer}/address/${bridged.recipient}`
+      },
+      { idempotencyKey }
+    );
+    return;
+  }
+  if (status?.status === "refund") {
+    printError(
+      `Relay refunded the bridge to ${from} on Base (minus gas)` + (status.failReason ? `: ${status.failReason}` : "") + `. Request ${bridged.requestId}.`,
+      { idempotencyKey }
+    );
+    return;
+  }
+  if (status?.status === "failure") {
+    printError(
+      `The bridge failed` + (status.failReason ? `: ${status.failReason}` : "") + `. Request ${bridged.requestId}; check taskmarket wallet balance on Base and Tempo.`,
+      { idempotencyKey }
+    );
+    return;
+  }
+  printResult(
+    { ...output, explorerUrl: `${tempoExplorer}/address/${bridged.recipient}` },
+    {
+      idempotencyKey
+    }
+  );
+});
+
 // src/commands/wallet/index.ts
-var walletCommand = new Command57("wallet").description("Wallet management commands");
+var walletCommand = new Command63("wallet").description("Wallet management commands");
 walletCommand.addCommand(walletBalanceCommand);
 walletCommand.addCommand(walletImportCommand);
 walletCommand.addCommand(setWithdrawalAddressCommand);
 walletCommand.addCommand(getWithdrawalAddressCommand);
 walletCommand.addCommand(changeWithdrawalAddressCommand);
+walletCommand.addCommand(syncWithdrawalAddressCommand);
 walletCommand.addCommand(revealRecoveryCodeCommand);
 walletCommand.addCommand(publishKeyCommand);
 walletCommand.addCommand(withdrawDreamsCommand);
+walletCommand.addCommand(walletBridgeCommand);
 
 // src/commands/withdraw.ts
-import { Command as Command58 } from "commander";
-import { toHex as toHex2 } from "viem";
+import { Command as Command64 } from "commander";
+import { toHex as toHex3 } from "viem";
 var RECEIVE_POLICY_BLOCKED = "recipient_receive_policy_blocked";
 async function withdrawOnTempo(input) {
   const { keystore, chainId, withdrawalAddress, amountBaseUnits } = input;
@@ -3175,7 +4354,16 @@ async function withdrawOnTempo(input) {
     throw error;
   }
 }
-var USDC_TYPES = {
+function withdrawOutput(result, chainId) {
+  return {
+    txHash: result.txHash,
+    amountBaseUnits: result.amountBaseUnits,
+    amount: formatPaymentAmount(result.amountBaseUnits, chainId),
+    tokenSymbol: paymentTokenSymbol(chainId),
+    to: result.to
+  };
+}
+var USDC_TYPES2 = {
   TransferWithAuthorization: [
     { name: "from", type: "address" },
     { name: "to", type: "address" },
@@ -3185,7 +4373,7 @@ var USDC_TYPES = {
     { name: "nonce", type: "bytes32" }
   ]
 };
-var withdrawCommand = new Command58("withdraw").description(
+var withdrawCommand = new Command64("withdraw").description(
   "Withdraw the payment token (USDC on Base, OUSD on Tempo) to the registered withdrawal address"
 ).argument("<amount>", "Amount in whole tokens (e.g. 5 for 5 USDC or 5 OUSD)").action(async (amount) => {
   const parsed = parseFloat(amount);
@@ -3211,7 +4399,16 @@ var withdrawCommand = new Command58("withdraw").description(
     );
     return;
   }
-  const { withdrawalAddress, usdcDomain } = addressResponse;
+  let withdrawalAddress;
+  try {
+    withdrawalAddress = await verifyWithdrawalAddress(
+      keystore,
+      addressResponse.withdrawalAddress
+    );
+  } catch (err) {
+    renderFailure(err);
+    return;
+  }
   const { chainId } = selectedNetwork();
   if (paymentProtocolOf(chainId) === "mpp") {
     const { data: result2, idempotencyKey: idempotencyKey2 } = await withdrawOnTempo({
@@ -3220,10 +4417,14 @@ var withdrawCommand = new Command58("withdraw").description(
       withdrawalAddress,
       amountBaseUnits
     });
-    printResult(
-      { txHash: result2.txHash, amountBaseUnits: result2.amountBaseUnits, to: result2.to },
-      { idempotencyKey: idempotencyKey2 }
-    );
+    printResult(withdrawOutput(result2, chainId), { idempotencyKey: idempotencyKey2 });
+    return;
+  }
+  let domain;
+  try {
+    domain = paymentTokenDomain(chainId);
+  } catch (err) {
+    renderFailure(err);
     return;
   }
   const now = Math.floor(Date.now() / 1e3);
@@ -3233,12 +4434,12 @@ var withdrawCommand = new Command58("withdraw").description(
     value: amountBaseUnits,
     validAfter: String(now - 60),
     validBefore: String(now + 300),
-    nonce: toHex2(crypto.getRandomValues(new Uint8Array(32)))
+    nonce: toHex3(crypto.getRandomValues(new Uint8Array(32)))
   };
   const signature = await signTypedData(
     {
-      domain: usdcDomain,
-      types: USDC_TYPES,
+      domain,
+      types: USDC_TYPES2,
       primaryType: "TransferWithAuthorization",
       message: authorization
     },
@@ -3253,16 +4454,13 @@ var withdrawCommand = new Command58("withdraw").description(
       signature
     }
   );
-  printResult(
-    { txHash: result.txHash, amountBaseUnits: result.amountBaseUnits, to: result.to },
-    { idempotencyKey }
-  );
+  printResult(withdrawOutput(result, chainId), { idempotencyKey });
 });
 
 // src/commands/encrypt.ts
-import { Command as Command59 } from "commander";
+import { Command as Command65 } from "commander";
 import { promises as fs2 } from "fs";
-var encryptCommand = new Command59("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) => {
+var encryptCommand = new Command65("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 fs2.readFile(file);
@@ -3310,9 +4508,9 @@ var encryptCommand = new Command59("encrypt").description("Encrypt a file with E
 });
 
 // src/commands/decrypt.ts
-import { Command as Command60 } from "commander";
+import { Command as Command66 } from "commander";
 import { promises as fs3 } from "fs";
-var decryptCommand = new Command60("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) => {
+var decryptCommand = new Command66("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 fs3.readFile(file);
@@ -3352,7 +4550,7 @@ var decryptCommand = new Command60("decrypt").description("Decrypt a file using
 });
 
 // src/commands/xmtp.ts
-import { Command as Command61 } from "commander";
+import { Command as Command67 } from "commander";
 
 // src/lib/xmtp-client.ts
 import path2 from "path";
@@ -3457,7 +4655,7 @@ function shouldHandleEnvelope(envelope, options) {
   options.cache.add(key);
   return true;
 }
-function sleep(ms) {
+function sleep2(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 async function runStreamWithReconnect(options) {
@@ -3487,7 +4685,7 @@ async function runStreamWithReconnect(options) {
         throw error;
       }
       options.onReconnect?.(reconnectAttempt, error);
-      await sleep(backoffMs(reconnectAttempt));
+      await sleep2(backoffMs(reconnectAttempt));
     }
   }
 }
@@ -3633,7 +4831,7 @@ function toTransportError(error, fallbackMessage) {
   const message = error instanceof Error && error.message.length > 0 ? error.message : `${fallbackMessage} (${String(error)})`;
   return new XmtpTransportError(message, category, error);
 }
-function sleep2(ms) {
+function sleep3(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 function parseRetryAttempts() {
@@ -3661,7 +4859,7 @@ async function withRetry(operation, maxAttempts) {
       if (!mapped.retryable || attempt >= maxAttempts) {
         throw mapped;
       }
-      await sleep2(sendBackoffMs(attempt));
+      await sleep3(sendBackoffMs(attempt));
     }
   }
   throw new XmtpTransportError("XMTP retry attempts exhausted", "non-retryable");
@@ -4115,7 +5313,7 @@ function getDefaultQueryTimeoutMs() {
   }
   return Math.floor(parsed);
 }
-var xmtpCommand = new Command61("xmtp").description("Manage XMTP messaging for this agent");
+var xmtpCommand = new Command67("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({
@@ -4352,7 +5550,7 @@ xmtpCommand.command("purge").description("Revoke stale XMTP installations that h
 });
 
 // src/commands/daemon.ts
-import { Command as Command62 } from "commander";
+import { Command as Command68 } from "commander";
 function diffTaskStatuses(prev, next) {
   const changes = [];
   for (const [taskId, newStatus] of next) {
@@ -4380,7 +5578,7 @@ function sleepOrAbort(ms, signal) {
   });
 }
 var MAX_SEEN_TASK_IDS = 2e3;
-var daemonCommand = new Command62("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", "15000").option(
+var daemonCommand = new Command68("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", "15000").option(
   "--auction-poll-interval <ms>",
   "Poll interval for clock-based auction tasks (dutch/reverse_dutch) in milliseconds",
   "15000"
@@ -4713,11 +5911,11 @@ var daemonCommand = new Command62("daemon").description("Long-running agent daem
 );
 
 // src/commands/email/index.ts
-import { Command as Command71 } from "commander";
+import { Command as Command77 } from "commander";
 
 // src/commands/email/register.ts
-import { Command as Command63 } from "commander";
-var registerCommand = new Command63("register").description("Register an email address for this agent").requiredOption("--username <name>", "Desired username (e.g. myagent)").action(async (opts) => {
+import { Command as Command69 } from "commander";
+var registerCommand = new Command69("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)}`
   );
@@ -4738,8 +5936,8 @@ var registerCommand = new Command63("register").description("Register an email a
 });
 
 // src/commands/email/inbox.ts
-import { Command as Command64 } from "commander";
-var inboxCommand2 = new Command64("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 Command70 } from "commander";
+var inboxCommand2 = new Command70("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,
@@ -4754,8 +5952,8 @@ var inboxCommand2 = new Command64("inbox").description("List emails in your inbo
 });
 
 // src/commands/email/read.ts
-import { Command as Command65 } from "commander";
-var readCommand = new Command65("read").description("Read an email by ID (marks it as read)").argument("<id>", "Email ID").action(async (id) => {
+import { Command as Command71 } from "commander";
+var readCommand = new Command71("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,
@@ -4767,8 +5965,8 @@ var readCommand = new Command65("read").description("Read an email by ID (marks
 });
 
 // src/commands/email/send.ts
-import { Command as Command66 } from "commander";
-var sendCommand = new Command66("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 Command72 } from "commander";
+var sendCommand = new Command72("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 { data: result, idempotencyKey } = await apiPost("/api/emails/send", {
     deviceId: keystore.deviceId,
@@ -4781,8 +5979,8 @@ var sendCommand = new Command66("send").description("Send an email").requiredOpt
 });
 
 // src/commands/email/reply.ts
-import { Command as Command67 } from "commander";
-var replyCommand = new Command67("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 Command73 } from "commander";
+var replyCommand = new Command73("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,
@@ -4804,8 +6002,8 @@ var replyCommand = new Command67("reply").description("Reply to an email").argum
 });
 
 // src/commands/email/delete.ts
-import { Command as Command68 } from "commander";
-var deleteCommand = new Command68("delete").description("Delete an email by ID").argument("<id>", "Email ID").action(async (id) => {
+import { Command as Command74 } from "commander";
+var deleteCommand = new Command74("delete").description("Delete an email by ID").argument("<id>", "Email ID").action(async (id) => {
   const keystore = await loadKeystore();
   const { data: result, idempotencyKey } = await apiPost(
     "/api/emails/delete",
@@ -4819,15 +6017,15 @@ var deleteCommand = new Command68("delete").description("Delete an email by ID")
 });
 
 // src/commands/email/address.ts
-import { Command as Command69 } from "commander";
-var addressCommand2 = new Command69("address").description("Show your registered email address").action(async () => {
+import { Command as Command75 } from "commander";
+var addressCommand2 = new Command75("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 Command70 } from "commander";
+import { Command as Command76 } from "commander";
 async function setReadStatus(id, read) {
   const keystore = await loadKeystore();
   const { data: result, idempotencyKey } = await apiPost(
@@ -4841,12 +6039,12 @@ async function setReadStatus(id, read) {
   );
   printResult({ id: result.id, isRead: result.isRead }, { idempotencyKey });
 }
-var markReadCommand = new Command70("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 Command76("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 Command71("email").description("Email management commands");
+var emailCommand = new Command77("email").description("Email management commands");
 emailCommand.addCommand(registerCommand);
 emailCommand.addCommand(inboxCommand2);
 emailCommand.addCommand(readCommand);
@@ -4856,12 +6054,158 @@ emailCommand.addCommand(deleteCommand);
 emailCommand.addCommand(addressCommand2);
 emailCommand.addCommand(markReadCommand);
 
+// src/commands/bug/index.ts
+import { Command as Command81 } from "commander";
+
+// src/commands/bug/list.ts
+import { Command as Command78 } from "commander";
+var listCommand = new Command78("list").description("List the bug reports you submitted and their status").option("--status <status>", `Only reports with this status: ${BUG_REPORT_STATUSES.join(", ")}`).option("--limit <n>", "Maximum reports to return (1-100)", "50").action(async (opts) => {
+  if (opts.status && !BUG_REPORT_STATUSES.includes(opts.status)) {
+    printError(`--status must be one of ${BUG_REPORT_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 auth = await signReadAuth();
+  if (!auth || Object.keys(auth.headers).length === 0) {
+    printError("Listing bug reports needs a wallet. Run `taskmarket init` first.");
+    return;
+  }
+  const params = new URLSearchParams({ limit: String(limit) });
+  if (opts.status) params.set("status", opts.status);
+  try {
+    printResult(
+      await apiGet(`/api/bug-reports/mine?${params.toString()}`, { headers: auth.headers })
+    );
+  } catch (error) {
+    return renderFailure(error);
+  }
+});
+
+// src/commands/bug/show.ts
+import { Command as Command79 } from "commander";
+var UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var showCommand = new Command79("show").description("Show one of your bug reports, its status and any linked GitHub issue").argument("<id>", "Bug report id").action(async (id) => {
+  if (!UUID.test(id)) {
+    printError("Bug report id must be a UUID");
+    return;
+  }
+  const auth = await signReadAuth();
+  if (!auth || Object.keys(auth.headers).length === 0) {
+    printError("Reading a bug report needs a wallet. Run `taskmarket init` first.");
+    return;
+  }
+  try {
+    printResult(await apiGet(`/api/bug-reports/${id}`, { headers: auth.headers }));
+  } catch (error) {
+    return renderFailure(error);
+  }
+});
+
+// src/commands/bug/submit.ts
+import { Command as Command80 } from "commander";
+
+// src/commands/bug/context.ts
+import os from "os";
+function collectBugContext(cliVersion2, extra) {
+  return {
+    cliVersion: cliVersion2,
+    os: `${os.platform()} ${os.release()} ${os.arch()}`,
+    nodeVersion: process.version,
+    network: selectedNetwork().name,
+    ...extra.taskId ? { taskId: extra.taskId } : {},
+    ...extra.txHash ? { txHash: extra.txHash } : {}
+  };
+}
+function cliVersionOf(command) {
+  let root = command;
+  while (root.parent) root = root.parent;
+  return root.version() ?? "unknown";
+}
+
+// src/commands/bug/submit.ts
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) chunks.push(Buffer.from(chunk));
+  return Buffer.concat(chunks).toString("utf8");
+}
+var submitCommand = new Command80("submit").description("Report a Taskmarket bug; CLI version, OS, Node version and network are attached").requiredOption("--title <text>", "Short summary (at most 200 characters)").option(
+  "--description <text>",
+  'What happened and how to reproduce it; read from stdin when omitted or "-"'
+).option("--severity <level>", `How bad it is: ${BUG_REPORT_SEVERITIES.join(", ")}`, "medium").option("--task <id>", "Task the bug happened on").option("--tx <hash>", "Transaction hash involved").option(
+  "--include-last-error",
+  "Attach the last failed taskmarket command and its error (secrets already removed)"
+).action(async function(opts) {
+  let description = opts.description;
+  if (description === void 0 || description === "-") {
+    if (process.stdin.isTTY) {
+      printError("Pass --description or pipe the description on stdin");
+      return;
+    }
+    description = await readStdin();
+  }
+  const context = collectBugContext(cliVersionOf(this), { taskId: opts.task, txHash: opts.tx });
+  if (opts.includeLastError) {
+    const lastError = readLastError();
+    if (!lastError) {
+      printError("No failed command is recorded yet; run without --include-last-error");
+      return;
+    }
+    context.command = lastError.command;
+    context.error = JSON.stringify({
+      message: lastError.message,
+      code: lastError.code,
+      status: lastError.status,
+      at: lastError.at,
+      cliVersion: lastError.cliVersion
+    });
+  }
+  const parsed = SubmitBugReportInputSchema.safeParse({
+    title: opts.title,
+    description,
+    severity: opts.severity,
+    source: "cli",
+    context
+  });
+  if (!parsed.success) {
+    const issue = parsed.error.issues[0];
+    printError(`Invalid bug report: ${issue.path.join(".") || "input"}: ${issue.message}`);
+    return;
+  }
+  const auth = await signReadAuth();
+  if (!auth || Object.keys(auth.headers).length === 0) {
+    printError("Reporting a bug needs a wallet. Run `taskmarket init` first.");
+    return;
+  }
+  try {
+    const { data, idempotencyKey } = await apiPost(
+      "/api/bug-reports",
+      parsed.data,
+      { headers: auth.headers }
+    );
+    printResult(data, { idempotencyKey });
+  } catch (error) {
+    return renderFailure(error);
+  }
+});
+
+// src/commands/bug/index.ts
+var bugCommand = new Command81("bug").description(
+  "Report Taskmarket bugs and follow their status"
+);
+bugCommand.addCommand(submitCommand);
+bugCommand.addCommand(listCommand);
+bugCommand.addCommand(showCommand);
+
 // src/commands/requester/index.ts
-import { Command as Command73 } from "commander";
+import { Command as Command83 } from "commander";
 
 // src/commands/requester/stats.ts
-import { Command as Command72 } from "commander";
-var requesterStatsCmd = new Command72("stats").description("Get requester reputation stats for an address").argument("<address>", "Wallet address of the requester").action(async (address) => {
+import { Command as Command82 } from "commander";
+var requesterStatsCmd = new Command82("stats").description("Get requester reputation stats for an address").argument("<address>", "Wallet address of the requester").action(async (address) => {
   if (!/^0x[0-9a-fA-F]{40}$/.test(address)) {
     printError("Address must be a 0x-prefixed 20-byte hex string");
     return;
@@ -4875,13 +6219,13 @@ var requesterStatsCmd = new Command72("stats").description("Get requester reputa
 });
 
 // src/commands/requester/index.ts
-var requesterCmd = new Command73("requester").description("Requester reputation commands").addCommand(requesterStatsCmd);
+var requesterCmd = new Command83("requester").description("Requester reputation commands").addCommand(requesterStatsCmd);
 
 // src/commands/x402/index.ts
-import { Command as Command77 } from "commander";
+import { Command as Command87 } from "commander";
 
 // src/commands/x402/payments.ts
-import { Command as Command74, Option as Option3 } from "commander";
+import { Command as Command84, Option as Option4 } from "commander";
 import { createInterface as createInterface4 } from "readline";
 var PAYMENT_STATES = [
   "reserved",
@@ -4907,10 +6251,10 @@ async function confirmManualResolution() {
   readline.close();
   return answer.trim().toLowerCase() === "resolve";
 }
-var x402PaymentsCommand = new Command74("payments").description(
+var x402PaymentsCommand = new Command84("payments").description(
   "Inspect and reconcile X402 Pay payment records"
 );
-x402PaymentsCommand.command("list").description("List current payment records").addOption(new Option3("--state <state>", "Filter by state").choices(PAYMENT_STATES)).action(async (options) => {
+x402PaymentsCommand.command("list").description("List current payment records").addOption(new Option4("--state <state>", "Filter by state").choices(PAYMENT_STATES)).action(async (options) => {
   const payments = await listX402Payments({ state: options.state }, getX402JournalPath());
   printResult({ payments });
 });
@@ -4936,7 +6280,7 @@ x402PaymentsCommand.command("resolve").description("Manually record an externall
 
 // src/commands/x402/policy.ts
 import { promises as fs4 } from "fs";
-import { Command as Command75 } from "commander";
+import { Command as Command85 } from "commander";
 import { createInterface as createInterface5 } from "readline";
 async function confirmUnattendedRule(rule) {
   if (!process.stdin.isTTY) {
@@ -4962,7 +6306,7 @@ async function confirmUnattendedRule(rule) {
   readline.close();
   return answer.trim().toLowerCase() === "authorize";
 }
-var x402PolicyCommand = new Command75("policy").description(
+var x402PolicyCommand = new Command85("policy").description(
   "Manage local X402 Pay spending policy"
 );
 x402PolicyCommand.command("init").description("Create a deny-all policy file").action(async () => {
@@ -4998,17 +6342,17 @@ for (const enabled of [true, false]) {
 }
 
 // src/commands/x402/request.ts
-import { Command as Command76, Option as Option4 } from "commander";
-function collect2(value, previous) {
+import { Command as Command86, Option as Option5 } from "commander";
+function collect3(value, previous) {
   return [...previous, value];
 }
 function confirm(lines) {
   return confirmAtTerminal(lines, "use --non-interactive with policy");
 }
-var x402RequestCommand = new Command76("request").description("Request and pay for a direct x402 HTTP resource (X402 Pay)").argument("<url>", "HTTPS resource URL").addOption(new Option4("--method <method>", "HTTP method").choices(["GET", "POST"]).default("GET")).option("--json <json>", "Inline JSON POST body").option("--body-file <path>", "Read JSON POST body from a file").option("--headers-file <path>", "Read request headers from an owner-only JSON file").option(
+var x402RequestCommand = new Command86("request").description("Request and pay for a direct x402 HTTP resource (X402 Pay)").argument("<url>", "HTTPS resource URL").addOption(new Option5("--method <method>", "HTTP method").choices(["GET", "POST"]).default("GET")).option("--json <json>", "Inline JSON POST body").option("--body-file <path>", "Read JSON POST body from a file").option("--headers-file <path>", "Read request headers from an owner-only JSON file").option(
   "--header-env <header=ENV_VAR>",
   "Read one request header from an environment variable (repeatable)",
-  collect2,
+  collect3,
   []
 ).option("--output <path>", "Write response bytes to a new file").option("--non-interactive", "Authorize only through a persistent unattended policy rule").option("--policy <ruleId>", "Restrict authorization to one policy rule").option(
   "--invocation-id <id>",
@@ -5045,7 +6389,7 @@ var x402RequestCommand = new Command76("request").description("Request and pay f
         `Asset: ${details.asset}`,
         `Spender: ${details.spender}`,
         `Bounded allowance: ${details.allowance} atomic units`,
-        `Estimated maximum gas: ${details.estimatedGasWei} wei`
+        details.estimatedGasUsd ? `Estimated maximum gas: ${details.estimatedGasUsd} (paid in the fee token)` : `Estimated maximum gas: ${details.estimatedGasWei} wei`
       ])
     });
     printResult(result);
@@ -5053,7 +6397,7 @@ var x402RequestCommand = new Command76("request").description("Request and pay f
 );
 
 // src/commands/x402/index.ts
-var x402Command = new Command77("x402").description(
+var x402Command = new Command87("x402").description(
   "Pay x402 services with local spending policies (X402 Pay)"
 );
 x402Command.addCommand(x402RequestCommand);
@@ -5061,11 +6405,11 @@ x402Command.addCommand(x402PolicyCommand);
 x402Command.addCommand(x402PaymentsCommand);
 
 // src/commands/sponsored-task/index.ts
-import { Command as Command92 } from "commander";
+import { Command as Command102 } from "commander";
 
 // src/commands/sponsored-task/create.ts
-import { Command as Command78 } from "commander";
-import { toHex as toHex3 } from "viem";
+import { Command as Command88 } from "commander";
+import { toHex as toHex4 } from "viem";
 
 // ../../packages/contracts/abi/generated/SponsoredTasksVault.ts
 var SponsoredTasksVaultABI = [
@@ -8186,7 +9530,7 @@ import {
   createPublicClient,
   createWalletClient,
   defineChain,
-  http as http2
+  http
 } from "viem";
 function resolveRpcUrl() {
   const value = process.env["TASKMARKET_RPC_URL"]?.trim();
@@ -8205,13 +9549,13 @@ async function createSponsoredTaskVaultChainClients(keystore, chainId) {
     nativeCurrency: { name: "Native gas token", symbol: "GAS", decimals: 18 },
     rpcUrls: { default: { http: [rpcUrl] } }
   });
-  const publicClient = createPublicClient({ chain, transport: http2(rpcUrl) });
+  const publicClient = createPublicClient({ chain, transport: http(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 = createWalletClient({ account, chain, transport: http2(rpcUrl) });
+  const walletClient = createWalletClient({ account, chain, transport: http(rpcUrl) });
   return { account, chain, publicClient, walletClient };
 }
 async function writeSponsoredTaskVaultContract(input) {
@@ -8286,7 +9630,7 @@ async function approveSponsoredTaskSpend(input) {
 function isValidAddress4(addr) {
   return /^0x[a-fA-F0-9]{40}$/.test(addr);
 }
-var sponsoredTaskCreateCommand = new Command78("create").description("Create a new Sponsored Task vault for a project token").requiredOption("--factory <address>", "SponsoredTaskFactory contract address").requiredOption("--chain-id <id>", "Chain id the factory is deployed on").requiredOption("--token <address>", "Project ERC-20 token address to fund the vault with").option("--owner <address>", "Vault owner (defaults to your own wallet)").action(async (opts) => {
+var sponsoredTaskCreateCommand = new Command88("create").description("Create a new Sponsored Task vault for a project token").requiredOption("--factory <address>", "SponsoredTaskFactory contract address").requiredOption("--chain-id <id>", "Chain id the factory is deployed on").requiredOption("--token <address>", "Project ERC-20 token address to fund the vault with").option("--owner <address>", "Vault owner (defaults to your own wallet)").action(async (opts) => {
   if (!isValidAddress4(opts.factory) || !isValidAddress4(opts.token)) {
     printError("Invalid Ethereum address for --factory or --token");
     return;
@@ -8308,7 +9652,7 @@ var sponsoredTaskCreateCommand = new Command78("create").description("Create a n
     chainId
   );
   const vaultOwner = opts.owner ?? account.address;
-  const userSalt = toHex3(crypto.getRandomValues(new Uint8Array(32)));
+  const userSalt = toHex4(crypto.getRandomValues(new Uint8Array(32)));
   const { txHash, result } = await writeSponsoredTaskVaultContract({
     account,
     publicClient,
@@ -8323,11 +9667,11 @@ var sponsoredTaskCreateCommand = new Command78("create").description("Create a n
 });
 
 // src/commands/sponsored-task/fund.ts
-import { Command as Command79 } from "commander";
+import { Command as Command89 } from "commander";
 function isValidAddress5(addr) {
   return /^0x[a-fA-F0-9]{40}$/.test(addr);
 }
-var sponsoredTaskFundCommand = new Command79("fund").description("Fund a Sponsored Task vault with its project token (base units)").requiredOption("--vault <address>", "Vault address").requiredOption("--token <address>", "Project ERC-20 token address").requiredOption("--chain-id <id>", "Chain id the vault is deployed on").requiredOption("--amount <baseUnits>", "Amount to fund, in the token base units").action(async (opts) => {
+var sponsoredTaskFundCommand = new Command89("fund").description("Fund a Sponsored Task vault with its project token (base units)").requiredOption("--vault <address>", "Vault address").requiredOption("--token <address>", "Project ERC-20 token address").requiredOption("--chain-id <id>", "Chain id the vault is deployed on").requiredOption("--amount <baseUnits>", "Amount to fund, in the token base units").action(async (opts) => {
   if (!isValidAddress5(opts.vault) || !isValidAddress5(opts.token)) {
     printError("Invalid Ethereum address for --vault or --token");
     return;
@@ -8366,7 +9710,7 @@ var sponsoredTaskFundCommand = new Command79("fund").description("Fund a Sponsor
 });
 
 // src/commands/sponsored-task/managers.ts
-import { Command as Command80 } from "commander";
+import { Command as Command90 } from "commander";
 function isValidAddress6(addr) {
   return /^0x[a-fA-F0-9]{40}$/.test(addr);
 }
@@ -8412,7 +9756,7 @@ async function configure(opts) {
   });
   printResult({ txHash, manager: opts.manager, spendCap: cap.toString(), active: opts.active });
 }
-var sponsoredTaskManagersCommand = new Command80("managers").description(
+var sponsoredTaskManagersCommand = new Command90("managers").description(
   "Manage authorized managers for a Sponsored Task vault"
 );
 sponsoredTaskManagersCommand.command("add").description("Authorize a manager with a token-denominated spend cap").requiredOption("--vault <address>", "Vault address").requiredOption("--chain-id <id>", "Chain id the vault is deployed on").requiredOption("--manager <address>", "Manager address to authorize").requiredOption("--cap <baseUnits>", "Spend cap, in the project token base units").action((opts) => configure({ ...opts, active: true }));
@@ -8423,8 +9767,8 @@ sponsoredTaskManagersCommand.command("list").description("List a vault authorize
 });
 
 // src/commands/sponsored-task/managed.ts
-import { Command as Command81 } from "commander";
-var sponsoredTaskManagedCommand = new Command81("managed").description(
+import { Command as Command91 } from "commander";
+var sponsoredTaskManagedCommand = new Command91("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 address = opts.address;
@@ -8454,7 +9798,7 @@ var sponsoredTaskManagedCommand = new Command81("managed").description(
 });
 
 // src/commands/sponsored-task/fee-bank.ts
-import { Command as Command82 } from "commander";
+import { Command as Command92 } from "commander";
 function isValidAddress7(addr) {
   return /^0x[a-fA-F0-9]{40}$/.test(addr);
 }
@@ -8466,7 +9810,7 @@ async function requireKeystore2() {
     return null;
   }
 }
-var sponsoredTaskFeeBankCommand = new Command82("fee-bank").description(
+var sponsoredTaskFeeBankCommand = new Command92("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) => {
@@ -8550,8 +9894,8 @@ sponsoredTaskFeeBankCommand.command("withdraw").description("Withdraw unused USD
 );
 
 // src/commands/sponsored-task/list.ts
-import { Command as Command83 } from "commander";
-var sponsoredTaskListCommand = new Command83("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 Command93 } from "commander";
+var sponsoredTaskListCommand = new Command93("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");
@@ -8560,8 +9904,8 @@ var sponsoredTaskListCommand = new Command83("list").description("List Sponsored
 });
 
 // src/commands/sponsored-task/settlements.ts
-import { Command as Command84 } from "commander";
-var sponsoredTaskSettlementsCommand = new Command84("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) => {
+import { Command as Command94 } from "commander";
+var sponsoredTaskSettlementsCommand = new Command94("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");
@@ -8576,17 +9920,17 @@ var sponsoredTaskSettlementsCommand = new Command84("settlements").description("
 });
 
 // src/commands/sponsored-task/show.ts
-import { Command as Command85 } from "commander";
-var sponsoredTaskShowCommand = new Command85("show").description("Show a Sponsored Task vault by id").argument("<vaultId>", "Vault id").action(async (vaultId) => {
+import { Command as Command95 } from "commander";
+var sponsoredTaskShowCommand = new Command95("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 randomBytes2 } from "crypto";
-import { Command as Command86 } from "commander";
+import { randomBytes as randomBytes3 } from "crypto";
+import { Command as Command96 } from "commander";
 var REQUEST_TTL_SECONDS = 5 * 60;
-var sponsoredTaskRequestReviewCommand = new Command86("request-review").description("Ask Taskmarket curators to review a Sponsored Task vault (vault owner only)").argument("<vaultId>", "Vault id").action(async (vaultId) => {
+var sponsoredTaskRequestReviewCommand = new Command96("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();
@@ -8606,7 +9950,7 @@ var sponsoredTaskRequestReviewCommand = new Command86("request-review").descript
     );
     return;
   }
-  const nonce = `0x${randomBytes2(32).toString("hex")}`;
+  const nonce = `0x${randomBytes3(32).toString("hex")}`;
   const expiresAt = Math.floor(Date.now() / 1e3) + REQUEST_TTL_SECONDS;
   const signature = await signMessage(
     buildSponsoredTaskVaultReviewRequestMessage({
@@ -8643,18 +9987,18 @@ var sponsoredTaskRequestReviewCommand = new Command86("request-review").descript
 });
 
 // src/commands/sponsored-task/balance.ts
-import { Command as Command87 } from "commander";
-var sponsoredTaskBalanceCommand = new Command87("balance").description("Show a Sponsored Task vault funded/available/reserved balances").argument("<vaultId>", "Vault id").action(async (vaultId) => {
+import { Command as Command97 } from "commander";
+var sponsoredTaskBalanceCommand = new Command97("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 Command88 } from "commander";
+import { Command as Command98 } from "commander";
 function isValidAddress8(addr) {
   return /^0x[a-fA-F0-9]{40}$/.test(addr);
 }
-var sponsoredTaskWithdrawCommand = new Command88("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 Command98("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;
@@ -8684,11 +10028,11 @@ var sponsoredTaskWithdrawCommand = new Command88("withdraw").description("Withdr
 });
 
 // src/commands/sponsored-task/exit.ts
-import { Command as Command89 } from "commander";
+import { Command as Command99 } from "commander";
 function isValidAddress9(addr) {
   return /^0x[a-fA-F0-9]{40}$/.test(addr);
 }
-var sponsoredTaskExitCommand = new Command89("exit").description(
+var sponsoredTaskExitCommand = new Command99("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)) {
@@ -8724,7 +10068,7 @@ var sponsoredTaskExitCommand = new Command89("exit").description(
 });
 
 // src/commands/sponsored-task/claim.ts
-import { Command as Command90 } from "commander";
+import { Command as Command100 } from "commander";
 var CLAIM_TO_TYPES = {
   ClaimTo: [
     { name: "vaultId", type: "bytes32" },
@@ -8745,7 +10089,7 @@ function isRetryableClaimConflict(err) {
   return err instanceof ApiError && (err.status === 409 || err.status >= 500) && /retry/i.test(err.message);
 }
 async function postClaimWithRetry(path3, body, options = {}) {
-  const sleep3 = options.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+  const sleep4 = options.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
   const deadline = Date.now() + (options.budgetMs ?? CLAIM_RETRY_BUDGET_MS);
   const idempotencyKey = resolveIdempotencyKey();
   let delayMs = 500;
@@ -8754,12 +10098,12 @@ async function postClaimWithRetry(path3, body, options = {}) {
       return await apiPost(path3, body, { idempotencyKey });
     } catch (err) {
       if (!isRetryableClaimConflict(err) || Date.now() + delayMs > deadline) throw err;
-      await sleep3(delayMs);
+      await sleep4(delayMs);
       delayMs = Math.min(delayMs * 2, 4e3);
     }
   }
 }
-var sponsoredTaskClaimCommand = new Command90("claim").description("Claim your unclaimed Sponsored Task reward for a vault task").argument("<vaultId>", "Vault id").option(
+var sponsoredTaskClaimCommand = new Command100("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) => {
@@ -8780,7 +10124,13 @@ var sponsoredTaskClaimCommand = new Command90("claim").description("Claim your u
     );
     return;
   }
-  const destination = addressResponse.withdrawalAddress;
+  let destination;
+  try {
+    destination = await verifyWithdrawalAddress(keystore, addressResponse.withdrawalAddress);
+  } catch (err) {
+    renderFailure(err);
+    return;
+  }
   const entitlements = await apiGet(
     `/api/sponsored-task-vaults/${vaultId}/entitlements?workerAddress=${workerAddress}`
   );
@@ -8839,10 +10189,10 @@ var sponsoredTaskClaimCommand = new Command90("claim").description("Claim your u
 });
 
 // src/commands/sponsored-task/rewards.ts
-import { Command as Command91 } from "commander";
+import { Command as Command101 } from "commander";
 var REWARD_STATES = SponsoredTaskRewardStateSchema.options;
 var CLAIM_STATUSES = SponsoredTaskWorkerRewardClaimStatusSchema.options;
-var sponsoredTaskRewardsCommand = new Command91("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(
+var sponsoredTaskRewardsCommand = new Command101("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 address = opts.address;
     if (address === void 0) {
@@ -8882,7 +10232,7 @@ var sponsoredTaskRewardsCommand = new Command91("rewards").description("List Spo
 );
 
 // src/commands/sponsored-task/index.ts
-var sponsoredTaskCommand = new Command92("sponsored-task").description(
+var sponsoredTaskCommand = new Command102("sponsored-task").description(
   "Sponsored Task vault administration and reward claims"
 );
 sponsoredTaskCommand.addCommand(sponsoredTaskCreateCommand);
@@ -8903,7 +10253,8 @@ sponsoredTaskCommand.addCommand(sponsoredTaskRewardsCommand);
 // src/index.ts
 var require2 = createRequire(import.meta.url);
 var { version } = require2("../package.json");
-var program = new Command93();
+var program = new Command103();
+setLastErrorCliVersion(version);
 program.name("taskmarket").description("Taskmarket CLI for AI agents").version(version);
 program.option(
   "--network <name>",
@@ -8923,7 +10274,7 @@ program.addCommand(walletCommand);
 program.addCommand(addressCommand);
 program.addCommand(identityCommand);
 program.addCommand(statsCommand);
-program.addCommand(taskCommand);
+program.addCommand(taskCommand2);
 program.addCommand(agentCommand);
 program.addCommand(agentsCommand);
 program.addCommand(inboxCommand);
@@ -8939,6 +10290,7 @@ program.addCommand(requesterCmd);
 program.addCommand(legalCommand);
 program.addCommand(x402Command);
 program.addCommand(sponsoredTaskCommand);
+program.addCommand(bugCommand);
 void (async () => {
   try {
     await program.parseAsync(process.argv);