@lucid-agents/taskmarket 1.20.3 → 1.22.0

package/dist/index.js

@@ -14,7 +14,7 @@ import {
   signReadAuth,
   submitTaskFiles,
   taskAccessGrantHeaders
-} from "./chunk-H2XTB3NF.js";
+} from "./chunk-7MXTPGES.js";
 import {
   ComputeCreditError,
   applyComputeCreditSetup,
@@ -36,7 +36,7 @@ import {
   refusedPaidWrite,
   releasePendingComputePurchase,
   resolvePendingComputePurchases
-} from "./chunk-4EN2RUZ3.js";
+} from "./chunk-RSSJD6JU.js";
 import {
   MPP_TEMPO_DEFAULT_VALIDITY_SECONDS,
   X402PayError,
@@ -58,30 +58,43 @@ import {
   signSponsoredTempoTransfer,
   signTaskmarketFeePayment,
   signTypedData
-} from "./chunk-EMIVR2MT.js";
+} from "./chunk-BO3XPXQ6.js";
 import {
+  ActivityFeedInputSchema,
+  ActivityHeatmapInputSchema,
+  ActorType,
   AgentMessageEnvelopeSchema,
+  AgentTimeSeriesInputSchema,
   ApiError,
   BUG_REPORT_SEVERITIES,
   BUG_REPORT_STATUSES,
   BUG_REPORT_VISIBILITIES,
   BugReportMessageBodySchema,
+  CrossChainFundingConfigOutputSchema,
   DEFAULT_EVALUATION_WINDOW_HOURS,
   DEFAULT_TERMS_BOUNDS,
+  HookGetInputSchema,
+  HookIndexInputSchema,
   IntentStatusResponseSchema,
+  KeystoreExistsError,
   LegalAcceptanceResponseSchema,
   LegalBundleSchema,
   LegalChallengeResponseSchema,
   LegalStatusResponseSchema,
   NETWORKS,
   NETWORK_NAMES,
+  NetworkRequiredError,
   PUBLIC_BUG_REPORT_SORTS,
   PenaltyTo,
+  PlatformTimeSeriesInputSchema,
   PostBugReportMessageInputSchema,
   READ_AUTH_ADDRESS_HEADER,
   READ_AUTH_SIGNATURE_HEADER,
   REDACTED,
+  RELAY_BRIDGE_ROUTES,
   RejectOutcome,
+  RelayBridgeFundingConfigOutputSchema,
+  RelayBridgeRouteIdSchema,
   SponsoredTaskRewardStateSchema,
   SponsoredTaskWorkerRewardClaimStatusSchema,
   SubmissionReviewAssessmentInputSchema,
@@ -102,6 +115,12 @@ import {
   SubmissionReviewStartPayloadSchema,
   SubmissionReviewTaskInputSchema,
   SubmitBugReportInputSchema,
+  TaskDropDirectoryInputSchema,
+  TaskDropGetInputSchema,
+  TaskDropOfficialStatusInputSchema,
+  TaskDropOfficialSubscribeInputSchema,
+  TaskDropStatusInputSchema,
+  TaskDropSubscribeInputSchema,
   TaskTermsError,
   TermsPresetName,
   WALLET_BRIDGE_ORIGIN_CHAIN_ID,
@@ -130,6 +149,7 @@ import {
   chainInfoFor,
   claimStakeToPost,
   clientValidityWindowSeconds,
+  createKeystore,
   decryptPrivateKey,
   dreamsToUsd,
   encryptPrivateKey,
@@ -138,14 +158,17 @@ import {
   formatPaymentAmount,
   formatUsdcBaseUnits,
   generateKeypair,
+  getNetwork,
   getTaskmarketHome,
   idempotencyKeyForError,
   isInFlightApiError,
+  isNetworkName,
   isPendingApiError,
   isRecordingPendingResponse,
   isTaskmarketChainId,
   isTerminalWalletBridgeStatus,
   keystoreExists,
+  liveNetworkNames,
   loadKeystore,
   networkToStamp,
   paymentProtocolOf,
@@ -153,11 +176,13 @@ import {
   readFailureBody,
   readKeystoreNetwork,
   redactSecrets,
+  relayBridgeRoute,
   resolveIdempotencyKey,
   resolveNetwork,
   resolveTaskTerms,
   saveKeystore,
   selectedNetwork,
+  selectedNetworkOrUndefined,
   setSelectedNetwork,
   settlementActionExpiresAt,
   settlementActionRequiresExpiry,
@@ -167,19 +192,20 @@ import {
   withChainId,
   withErrorContext,
   withIdempotentWrite
-} from "./chunk-4SG3R5IH.js";
+} from "./chunk-H2HOWIJ6.js";
 import {
   channelLines
 } from "./chunk-XJOB4NMV.js";
 import "./chunk-S7SJMJ2I.js";
 
 // src/index.ts
-import { Command as Command109 } from "commander";
+import { Command as Command113 } from "commander";
 import { createRequire } from "module";
 
 // src/commands/init.ts
 import { Command as Command2 } from "commander";
 import { privateKeyToAccount } from "viem/accounts";
+import { createInterface as createInterface2 } from "readline";
 
 // src/lib/last-error.ts
 import fs from "fs";
@@ -308,21 +334,38 @@ function printWarning(message) {
 }
 
 // src/lib/agent.ts
+function legacyAgentIdChain(keystore) {
+  const network = keystore.network;
+  return network && isNetworkName(network) ? NETWORKS[network].chainId : void 0;
+}
+function agentIdForChain(keystore, chainId) {
+  const stored = keystore.agentIds?.[String(chainId)];
+  if (stored) return stored;
+  if (keystore.agentId && legacyAgentIdChain(keystore) === chainId) return keystore.agentId;
+  return null;
+}
+function withAgentIdForChain(keystore, chainId, agentId) {
+  return { ...keystore, agentIds: { ...keystore.agentIds, [String(chainId)]: agentId } };
+}
+async function lookupAgentId(address, chainId = selectedNetwork().chainId) {
+  try {
+    const res = await fetch(
+      `${apiUrl()}/api/identity/status?address=${address}&chainId=${chainId}`
+    );
+    if (!res.ok) return null;
+    const data = await res.json();
+    return data.agentId ?? null;
+  } catch {
+    return null;
+  }
+}
 async function pollAgentId(address, maxWaitMs = 6e4) {
   const interval = 3e3;
   const deadline = Date.now() + maxWaitMs;
   while (Date.now() < deadline) {
     await new Promise((r) => setTimeout(r, interval));
-    try {
-      const res = await fetch(
-        `${apiUrl()}/api/identity/status?address=${address}&chainId=${selectedNetwork().chainId}`
-      );
-      if (res.ok) {
-        const data = await res.json();
-        if (data.agentId) return data.agentId;
-      }
-    } catch {
-    }
+    const agentId = await lookupAgentId(address);
+    if (agentId) return agentId;
   }
   return null;
 }
@@ -346,10 +389,32 @@ async function registerDevice(input) {
   });
   if (!response.ok) {
     const text = await response.text().catch(() => "");
+    const limited = sponsoredMintRateLimitMessage(
+      response.status,
+      text,
+      response.headers.get("retry-after")
+    );
+    if (limited) throw new Error(limited);
     throw new Error(`Device registration failed (${response.status}): ${text}`);
   }
   return await response.json();
 }
+function sponsoredMintRateLimitMessage(status, body, retryAfter) {
+  let parsed = body;
+  if (typeof body === "string") {
+    try {
+      parsed = JSON.parse(body);
+    } catch {
+      parsed = void 0;
+    }
+  }
+  const envelope = parsed;
+  if (status !== 429 && envelope?.taskmarket?.reason !== "rate_limited") return void 0;
+  const seconds = Number(retryAfter);
+  const wait = Number.isFinite(seconds) && seconds > 0 ? `Retry after ${seconds} seconds.` : "Retry later.";
+  const detail = envelope?.message ?? envelope?.error?.message;
+  return `Sponsored identity registration is rate limited (rate_limited). ${detail ? `${detail} ` : ""}${wait}`.trim();
+}
 
 // src/lib/encryption.ts
 import { createECDH, hkdfSync, createCipheriv, createDecipheriv, randomBytes } from "crypto";
@@ -599,13 +664,42 @@ async function tryRegisterEmail(deviceId, apiToken, username, explicit) {
     return null;
   }
 }
-var initCommand = new Command2("init").description("Create and register a new agent wallet (safe to re-run)").option(
+function terminalIo() {
+  return {
+    interactive: Boolean(process.stdin.isTTY && process.stderr.isTTY),
+    ask: (question) => new Promise((resolve) => {
+      const rl = createInterface2({ input: process.stdin, output: process.stderr });
+      rl.question(question, (answer) => {
+        rl.close();
+        resolve(answer);
+      });
+    })
+  };
+}
+async function ensureInitNetwork(io = terminalIo()) {
+  if (selectedNetworkOrUndefined()) return;
+  if (!io.interactive) throw new NetworkRequiredError();
+  const answer = (await io.ask(`Network to use (${liveNetworkNames().join(", ")}): `)).trim();
+  if (!answer) throw new NetworkRequiredError();
+  setSelectedNetwork(getNetwork(answer));
+}
+function existingWalletMessage() {
+  return "This machine already has a Taskmarket wallet; init runs once and never replaces saved credentials. The same wallet and device credentials work on every network. To register its agent identity on another network, run: taskmarket --network <name> identity register";
+}
+var initCommand = new Command2("init").description(
+  "Create and register this machine's agent wallet (one-time; refuses when a wallet exists)"
+).option(
   "--email <username>",
   "Claim a custom email username (default: auto-generated from agent ID)"
 ).option(
   "--yes",
   "Confirm legal acceptance non-interactively after reviewing every current policy"
 ).action(async (opts) => {
+  if (await keystoreExists()) {
+    printError(existingWalletMessage());
+    return;
+  }
+  await ensureInitNetwork();
   if (opts.email) {
     const check = await apiGet(
       `/api/emails/check-username?username=${encodeURIComponent(opts.email)}`
@@ -615,56 +709,6 @@ var initCommand = new Command2("init").description("Create and register a new ag
       return;
     }
   }
-  if (await keystoreExists()) {
-    const keystore = await loadKeystore();
-    let agentId2 = keystore.agentId;
-    if (!agentId2) {
-      agentId2 = await pollAgentId(keystore.walletAddress);
-      if (agentId2) {
-        await saveKeystore({ ...keystore, agentId: agentId2 });
-      }
-    }
-    let networkInfo2;
-    try {
-      const response = await apiGet("/trpc/network.info");
-      networkInfo2 = response.result.data;
-    } catch {
-    }
-    let emailAddress2 = null;
-    try {
-      const existing = await apiGet(`/api/agents/stats?address=${keystore.walletAddress}`);
-      emailAddress2 = existing.emailAddress ?? null;
-    } catch {
-    }
-    if (!emailAddress2) {
-      const username2 = opts.email ?? (agentId2 && networkInfo2 ? sanitizeEmailUsername(agentId2, String(selectedNetwork().chainId)) : null);
-      if (username2) {
-        emailAddress2 = await tryRegisterEmail(
-          keystore.deviceId,
-          keystore.apiToken,
-          username2,
-          !!opts.email
-        );
-      }
-    }
-    let chain2;
-    try {
-      chain2 = chainInfoFor(networkInfo2, selectedNetwork().chainId);
-    } catch (err) {
-      renderFailure(err);
-      return;
-    }
-    printResult({
-      address: keystore.walletAddress,
-      agentId: agentId2,
-      network: chain2?.networkName ?? networkInfo2?.networkName,
-      chainId: chain2?.chainId ?? networkInfo2?.chainId,
-      paymentMethod: chain2?.paymentMethod,
-      feeModel: chain2?.feeModel,
-      emailAddress: emailAddress2
-    });
-    return;
-  }
   const { privateKey, address } = generateKeypair();
   const publicKey = deriveCompressedPublicKey(privateKey);
   const legalBundle = LegalBundleSchema.parse(await apiGet("/api/legal/current"));
@@ -690,12 +734,13 @@ var initCommand = new Command2("init").description("Create and register a new ag
   });
   const encryptedKey = encryptPrivateKey(deviceEncryptionKey, privateKey);
   let agentId = initialAgentId;
-  await saveKeystore({
+  const newKeystore = {
     encryptedKey,
     walletAddress: address,
     deviceId,
     apiToken,
     agentId,
+    ...agentId ? { agentIds: { [String(selectedNetwork().chainId)]: agentId } } : {},
     keyServerUrl: apiUrl(),
     network: networkToStamp(),
     ...legalAcceptance ? {
@@ -703,12 +748,25 @@ var initCommand = new Command2("init").description("Create and register a new ag
       legalAcceptanceBundleVersion: legalAcceptance.bundleVersion,
       legalAcceptanceReceipt: legalAcceptance.receipt
     } : {}
-  });
+  };
+  const created = await createKeystore(newKeystore).then(
+    () => true,
+    (error) => {
+      if (error instanceof KeystoreExistsError) return false;
+      throw error;
+    }
+  );
+  if (!created) {
+    printError(existingWalletMessage());
+    return;
+  }
   if (!agentId) {
     agentId = await pollAgentId(address);
     if (agentId) {
       const keystore = await loadKeystore();
-      await saveKeystore({ ...keystore, agentId });
+      await saveKeystore(
+        withAgentIdForChain({ ...keystore, agentId }, selectedNetwork().chainId, agentId)
+      );
     }
   }
   let networkInfo;
@@ -746,72 +804,50 @@ var addressCommand = new Command3("address").description("Print the wallet addre
 
 // src/commands/identity.ts
 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);
+var identityCommand = new Command4("identity").description("Manage agent identity");
+identityCommand.command("register").description(
+  "Register this wallet's ERC-8004 agent identity on the selected network (free; uses this machine's existing credentials)"
+).action(async () => {
   const keystore = await loadKeystore();
-  const idempotencyKey = resolveIdempotencyKey(options?.idempotencyKey);
-  const request = paidWriteRequest(keystore, path3, body, idempotencyKey);
-  return withIdempotentWrite(idempotencyKey, async () => {
-    const r1 = await fetch(request.url, {
-      method: "POST",
-      redirect: "error",
-      headers: request.headers,
-      body: request.body
-    });
-    if (r1.status !== 402) {
-      if (r1.ok) {
-        return { data: await r1.json(), idempotencyKey };
-      }
-      throw refusedPaidWrite(path3, r1.status, await readFailureBody(r1), idempotencyKey);
-    }
-    const requirements = await r1.json();
-    if (!requirements.accepts || requirements.accepts.length === 0) {
-      throw new Error("No payment methods accepted by server");
-    }
-    const accept = requirements.accepts[0];
-    const { header } = await signTaskmarketFeePayment({
-      resource: requirements.resource,
-      requirement: accept,
-      typedData: accept.extra.eip712,
-      from: keystore.walletAddress,
-      signTypedData: (typedData) => signTypedData(typedData, keystore)
-    });
-    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;
+  const chainId = selectedNetwork().chainId;
+  const stored = agentIdForChain(keystore, chainId);
+  if (stored) {
+    printResult({ agentId: stored, alreadyRegistered: true, chainId });
+    return;
+  }
+  let posted;
+  try {
+    posted = await apiPost(
+      `/api/devices/${encodeURIComponent(keystore.deviceId)}/identity`,
+      { deviceId: keystore.deviceId, apiToken: keystore.apiToken, chainId }
+    );
+  } catch (error) {
+    if (error instanceof ApiError) {
+      const limited = sponsoredMintRateLimitMessage(
+        error.status,
+        error.envelope ?? error.message
+      );
+      if (limited) {
+        renderFailure(new ApiError(error.status, limited, error.idempotencyKey, error.envelope));
+        return;
       }
-      throw failedAfterPayment(path3, r2.status, read, idempotencyKey);
     }
-  });
-}
-
-// src/commands/identity.ts
-var identityCommand = new Command4("identity").description("Manage agent identity");
-identityCommand.command("register").description("Register ERC-8004 agent identity (costs 0.001 in the payment token)").action(async () => {
-  const { data: result, idempotencyKey } = await x402Post("/api/identity/register", { chainId: selectedNetwork().chainId });
-  printResult({ agentId: result.agentId }, { idempotencyKey });
+    throw error;
+  }
+  const { data, idempotencyKey } = posted;
+  const agentId = data.agentId ?? await pollAgentId(keystore.walletAddress);
+  if (agentId) {
+    await saveKeystore(withAgentIdForChain(await loadKeystore(), chainId, agentId));
+    printResult(
+      { agentId, alreadyRegistered: data.alreadyRegistered, chainId },
+      { idempotencyKey }
+    );
+    return;
+  }
+  printError(
+    `The sponsored identity mint on chain ${chainId} has started but has not landed yet. Re-run this command to pick it up: ${taskmarketCommandFor(chainId)} identity register`,
+    { idempotencyKey }
+  );
 });
 identityCommand.command("status").description("Check identity registration status").action(async () => {
   const keystore = await loadKeystore();
@@ -845,7 +881,9 @@ function describeReputationLink(link) {
     return `unavailable: ${link.linkUnavailableReason ?? LINK_READ_FAILED_REASON}`;
   return link.linkedAgentId ? `linked to agent #${link.linkedAgentId}` : NOT_LINKED_YET;
 }
-var whoamiCommand = new Command5("whoami").description("Show this wallet, its agent ID on each chain and its requester reputation link").action(async () => {
+var whoamiCommand = new Command5("whoami").description(
+  "Show this wallet, its agent ID on each chain and its requester reputation link on the selected --network"
+).action(async () => {
   const keystore = await loadKeystore();
   const selected = selectedNetwork();
   const chains = await Promise.all(
@@ -870,7 +908,91 @@ var whoamiCommand = new Command5("whoami").description("Show this wallet, its ag
 
 // src/commands/stats.ts
 import { Command as Command6 } from "commander";
-var statsCommand = new Command6("stats").description("View agent statistics").option("--address <addr>", "Wallet address (defaults to own wallet)").option("--agent <agentId>", "Agent ID (alternative to --address)").action(async (opts) => {
+
+// src/lib/parse-input.ts
+function parseInput(schema, input) {
+  const result = schema.safeParse(input);
+  if (!result.success) {
+    const detail = result.error.issues.map((issue) => (issue.path.length > 0 ? `${issue.path.join(".")}: ` : "") + issue.message).join("; ");
+    throw new Error(`Invalid input: ${detail}`);
+  }
+  return result.data;
+}
+function optionalInt(value) {
+  if (value === void 0) return void 0;
+  const parsed = Number(value);
+  return Number.isInteger(parsed) ? parsed : Number.NaN;
+}
+
+// src/commands/stats.ts
+function 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.toString();
+}
+async function platformView(opts) {
+  const views = [opts.platform, opts.activity, opts.heatmap, opts.series].filter(Boolean).length;
+  if (views === 0) return false;
+  if (views > 1) {
+    throw new Error("Pass only one of --platform, --activity, --heatmap or --series");
+  }
+  if (opts.platform) {
+    const input2 = parseInput(PlatformTimeSeriesInputSchema, {
+      range: opts.range,
+      bucket: opts.bucket
+    });
+    const [market, breakdowns, timeSeries] = await Promise.all([
+      apiGet(withChainId("/api/market/stats")),
+      apiGet(withChainId("/api/stats/breakdowns")),
+      apiGet(withChainId(`/api/stats/platform-time-series?${query(input2)}`))
+    ]);
+    printResult({ chainId: selectedNetwork().chainId, market, breakdowns, timeSeries });
+    return true;
+  }
+  if (opts.activity) {
+    const input2 = parseInput(ActivityFeedInputSchema, {
+      limit: optionalInt(opts.limit),
+      cursor: opts.cursor
+    });
+    printResult(
+      await apiGet(
+        withChainId(
+          `/api/stats/activity-feed?${query({ limit: input2.limit, cursor: input2.cursor })}`
+        )
+      )
+    );
+    return true;
+  }
+  if (opts.heatmap) {
+    const input2 = parseInput(ActivityHeatmapInputSchema, {
+      range: opts.range,
+      dimension: opts.dimension
+    });
+    printResult(await apiGet(withChainId(`/api/stats/activity-heatmap?${query(input2)}`)));
+    return true;
+  }
+  let address = opts.address;
+  if (!address && !opts.agent) {
+    address = (await loadKeystore()).walletAddress;
+  }
+  const input = parseInput(AgentTimeSeriesInputSchema, {
+    address: opts.agent ? void 0 : address,
+    agentId: opts.agent,
+    range: opts.range,
+    bucket: opts.bucket
+  });
+  printResult(await apiGet(withChainId(`/api/stats/agent-time-series?${query(input)}`)));
+  return true;
+}
+var statsCommand = new Command6("stats").description("View agent or platform-wide statistics on the selected --network").option("--address <addr>", "Wallet address (defaults to own wallet)").option("--agent <agentId>", "Agent ID (alternative to --address)").option("--platform", "Platform-wide market stats, breakdowns and time series").option("--activity", "Recent platform activity feed").option("--heatmap", "Market activity heat map").option("--series", "An agent's earnings, ratings and activity time series").option("--range <range>", "Time range for --platform, --heatmap, --series: 7d, 30d, 90d or all").option("--bucket <bucket>", "Bucket for --platform and --series: day or week").option("--dimension <dimension>", "Heat map dimension for --heatmap: mode or hourOfWeek").option("--limit <n>", "Items for --activity (1-50)").option("--cursor <cursor>", "nextCursor from a previous --activity page").action(async (opts) => {
+  try {
+    if (await platformView(opts)) return;
+  } catch (err) {
+    renderFailure(err);
+    return;
+  }
   let address = opts.address;
   if (!address) {
     const keystore = await loadKeystore();
@@ -913,7 +1035,12 @@ var statsCommand = new Command6("stats").description("View agent statistics").op
     ratedTasks: result.ratedTasks,
     averageRating: result.averageRating,
     credibility: result.credibility,
+    // Paid on the selected chain, in its token; earningsByChain lists every chain where the
+    // wallet earned, each in its own token, never summed.
     totalEarnings: result.totalEarnings,
+    earningsChainId: selectedNetwork().chainId,
+    earningsToken: paymentTokenSymbol(selectedNetwork().chainId),
+    earningsByChain: result.earningsByChain ?? [],
     skills: result.skills,
     emailAddress: result.emailAddress,
     recentRatings: result.recentRatings
@@ -938,7 +1065,7 @@ var correctionOutput = z.object({
   correctionId: z.string().uuid(),
   createdAt: z.string().datetime()
 });
-var query = (values) => {
+var query2 = (values) => {
   const params = new URLSearchParams();
   for (const [key, value] of Object.entries(values))
     if (value !== void 0) params.set(key, String(value));
@@ -998,7 +1125,7 @@ function createSubmissionReviewClient(options) {
     async profile(input) {
       const { taskId, ...params } = SubmissionReviewTaskInputSchema.parse(input);
       return get(
-        `${taskPath(taskId)}/submission-review-profile${query(params)}`,
+        `${taskPath(taskId)}/submission-review-profile${query2(params)}`,
         SubmissionReviewProfileOutputSchema
       );
     },
@@ -1041,12 +1168,12 @@ function createSubmissionReviewClient(options) {
     },
     async status(input) {
       const { runId, ...params } = SubmissionReviewRunInputSchema.parse(input);
-      return get(`${runPath(runId)}${query(params)}`, SubmissionReviewRunSummarySchema);
+      return get(`${runPath(runId)}${query2(params)}`, SubmissionReviewRunSummarySchema);
     },
     async lookup(input) {
       const { idempotencyKey, ...params } = SubmissionReviewLookupInputSchema.parse(input);
       return get(
-        `/api/submission-review-requests/${idempotencyKey}${query(params)}`,
+        `/api/submission-review-requests/${idempotencyKey}${query2(params)}`,
         SubmissionReviewRunSummarySchema
       );
     },
@@ -1065,7 +1192,7 @@ function createSubmissionReviewClient(options) {
     async results(input) {
       const { taskId, ...params } = SubmissionReviewResultsInputSchema.parse(input);
       return get(
-        `${taskPath(taskId)}/submission-review-results${query(params)}`,
+        `${taskPath(taskId)}/submission-review-results${query2(params)}`,
         SubmissionReviewResultsOutputSchema
       );
     },
@@ -1097,14 +1224,14 @@ function createSubmissionReviewClient(options) {
     async history(input) {
       const { taskId, ...params } = SubmissionReviewHistoryInputSchema.parse(input);
       return get(
-        `${taskPath(taskId)}/submission-reviews${query(params)}`,
+        `${taskPath(taskId)}/submission-reviews${query2(params)}`,
         SubmissionReviewHistoryOutputSchema
       );
     },
     async assessment(input) {
       const { runId, submissionId, ...params } = SubmissionReviewAssessmentInputSchema.parse(input);
       return get(
-        `${runPath(runId)}/assessments/${encodeURIComponent(submissionId)}${query(params)}`,
+        `${runPath(runId)}/assessments/${encodeURIComponent(submissionId)}${query2(params)}`,
         SubmissionReviewAssessmentOutputSchema
       );
     },
@@ -1342,6 +1469,66 @@ var reviewCmd = createReviewCommand();
 import { Command as Command8 } from "commander";
 import { parseUnits } from "viem";
 
+// 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();
+  const idempotencyKey = resolveIdempotencyKey(options?.idempotencyKey);
+  const request = paidWriteRequest(keystore, path3, body, idempotencyKey);
+  return withIdempotentWrite(idempotencyKey, async () => {
+    const r1 = await fetch(request.url, {
+      method: "POST",
+      redirect: "error",
+      headers: request.headers,
+      body: request.body
+    });
+    if (r1.status !== 402) {
+      if (r1.ok) {
+        return { data: await r1.json(), idempotencyKey };
+      }
+      throw refusedPaidWrite(path3, r1.status, await readFailureBody(r1), idempotencyKey);
+    }
+    const requirements = await r1.json();
+    if (!requirements.accepts || requirements.accepts.length === 0) {
+      throw new Error("No payment methods accepted by server");
+    }
+    const accept = requirements.accepts[0];
+    const { header } = await signTaskmarketFeePayment({
+      resource: requirements.resource,
+      requirement: accept,
+      typedData: accept.extra.eip712,
+      from: keystore.walletAddress,
+      signTypedData: (typedData) => signTypedData(typedData, keystore)
+    });
+    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);
+    }
+  });
+}
+
 // src/lib/settlement-terms.ts
 var TERM_FLAGS = {
   stakeRequired: "--stake-required",
@@ -3258,14 +3445,14 @@ import { Command as Command49, Option as Option3 } from "commander";
 import { Command as Command47 } from "commander";
 
 // src/lib/tty-confirm.ts
-import { createInterface as createInterface2 } from "readline";
+import { createInterface as createInterface3 } from "readline";
 async function confirmAtTerminal(lines, unattended) {
   if (!process.stdin.isTTY) {
     throw new Error(`Interactive confirmation requires a TTY; ${unattended}`);
   }
   process.stderr.write(`${lines.join("\n")}
 `);
-  const readline = createInterface2({ input: process.stdin, output: process.stderr });
+  const readline = createInterface3({ input: process.stdin, output: process.stderr });
   const answer = await new Promise(
     (resolve) => readline.question("Type yes to approve: ", resolve)
   );
@@ -3457,7 +3644,7 @@ async function runAgentCommand(options) {
   try {
     const { assertAgentCompatibility } = await import("./compatibility-636WJOEX.js");
     const pi = assertAgentCompatibility();
-    const { runAgent } = await import("./launch-MX3RJWL7.js");
+    const { runAgent } = await import("./launch-UUW34PHS.js");
     result = await runAgent({
       model: options.model,
       pi,
@@ -3516,13 +3703,13 @@ function agentManagementCommands() {
   const status = new Command48("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-JCOPIQ7O.js");
+    const { collectAgentStatus, statusLines } = await import("./status-5AVXIFQJ.js");
     await run(options, () => collectAgentStatus(), statusLines);
   });
   const doctor = new Command48("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-Z5O2VY62.js");
+    const { runDoctor, doctorLines } = await import("./doctor-MZUDBF4B.js");
     const report = await run(options, () => runDoctor(), doctorLines);
     if (report && !report.ok) process.exitCode = 1;
   });
@@ -3533,7 +3720,7 @@ function agentManagementCommands() {
     "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-OAT32H4B.js");
+      const { reconcileChannelPurchases, reconcileInvocation } = await import("./reconcile-NDPFPJEB.js");
       const choice = { rail: options.rail, channel: options.channel };
       if (invocationId !== void 0) {
         await run(
@@ -3591,7 +3778,7 @@ function agentManagementCommands() {
             `Not a USDC amount: ${options.amount} (digits, at most 6 decimals)`
           );
         }
-        const { openAgentChannels, requestTopUp, selectRail, withdrawalHatch } = await import("./channels-B4HKYLKV.js");
+        const { openAgentChannels, requestTopUp, selectRail, withdrawalHatch } = await import("./channels-NUZWFG26.js");
         const { rails } = await openAgentChannels();
         const result = await requestTopUp(selectRail(rails, options.rail), amount);
         return {
@@ -3615,8 +3802,8 @@ function agentManagementCommands() {
       async () => {
         await requireExperimental();
         const { AGENT_VIEW_VERSION } = await import("./budget-view-J6L7X6EY.js");
-        const { closeChannel, openAgentChannels, selectChannel } = await import("./channels-B4HKYLKV.js");
-        const { reconcileLeasedPurchase } = await import("./reconcile-OAT32H4B.js");
+        const { closeChannel, openAgentChannels, selectChannel } = await import("./channels-NUZWFG26.js");
+        const { reconcileLeasedPurchase } = await import("./reconcile-NDPFPJEB.js");
         const opened = await openAgentChannels();
         const { rail, retired } = selectChannel(opened, options);
         const result = await closeChannel(
@@ -3687,7 +3874,7 @@ function agentManagementCommands() {
         options,
         async () => {
           await requireExperimental();
-          const { runPull } = await import("./sync-pull-D4DZ2LYX.js");
+          const { runPull } = await import("./sync-pull-FHKF7A44.js");
           const { terminalPrompter } = await import("./prompter-LSICEYSQ.js");
           return runPull(options, {
             interactive: Boolean(process.stdin.isTTY && process.stdout.isTTY) && !options.json,
@@ -3750,16 +3937,36 @@ for (const command of agentManagementCommands()) {
 
 // src/commands/agents.ts
 import { Command as Command50 } from "commander";
-var agentsCommand = new Command50("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);
-  if (opts.search) params.set("search", opts.search);
-  if (opts.limit) params.set("limit", opts.limit);
-  params.set("chainId", String(selectedNetwork().chainId));
-  const result = await apiGet(`/api/agents/leaderboard?${params.toString()}`);
-  printResult(result);
-});
+var agentsCommand = new Command50("agents").description("Browse the agent directory on the selected --network").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").option(
+  "--kind <kind>",
+  "Filter by actor kind: agent, human (the web humans directory) or hosted"
+).action(
+  async (opts) => {
+    let kind;
+    try {
+      kind = opts.kind === void 0 ? void 0 : parseInput(ActorType, opts.kind);
+    } catch (err) {
+      renderFailure(err);
+      return;
+    }
+    const params = new URLSearchParams();
+    if (opts.sort) params.set("sort", opts.sort);
+    if (opts.skill) params.set("skill", opts.skill);
+    if (opts.search) params.set("search", opts.search);
+    if (opts.limit) params.set("limit", opts.limit);
+    if (kind) params.set("actorType", kind);
+    const { chainId } = selectedNetwork();
+    params.set("chainId", String(chainId));
+    const result = await apiGet(`/api/agents/leaderboard?${params.toString()}`);
+    printResult(
+      Array.isArray(result) ? result.map((entry) => ({
+        ...entry,
+        earningsChainId: chainId,
+        earningsToken: paymentTokenSymbol(chainId)
+      })) : result
+    );
+  }
+);
 
 // src/commands/inbox.ts
 import { Command as Command51 } from "commander";
@@ -3800,7 +4007,94 @@ var actionsCommand = new Command52("actions").description("Show lifecycle action
 
 // src/commands/deposit.ts
 import { Command as Command53 } from "commander";
-var depositCommand = new Command53("deposit").description("Show wallet address and network info for funding").action(async () => {
+
+// src/lib/relay-bridge.ts
+import { z as z3 } from "zod";
+var RELAY_API_BASE_URL = "https://api.relay.link";
+var RelayQuoteResponseSchema = z3.object({
+  requestId: z3.string().min(1),
+  steps: z3.array(
+    z3.object({
+      depositAddress: z3.string().regex(/^0x[a-fA-F0-9]{40}$/).optional()
+    })
+  ).optional(),
+  details: z3.object({
+    currencyOut: z3.object({
+      amount: z3.string().regex(/^[0-9]+$/).optional()
+    }).optional()
+  }).optional()
+});
+async function requestRelayBridgeDepositAddress(request, fetchImpl = fetch) {
+  const route = relayBridgeRoute(request.routeId);
+  const res = await fetchImpl(`${RELAY_API_BASE_URL}/quote`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      user: request.recipient,
+      recipient: request.recipient,
+      originChainId: route.origin.chainId,
+      originCurrency: route.origin.currency,
+      destinationChainId: route.destination.chainId,
+      destinationCurrency: route.destination.currency,
+      amount: request.amountBaseUnits,
+      tradeType: "EXACT_INPUT",
+      useDepositAddress: true
+    })
+  });
+  if (!res.ok) {
+    throw new Error(`Relay quote request failed: ${res.status}`);
+  }
+  const parsed = RelayQuoteResponseSchema.safeParse(await res.json());
+  const depositAddress = parsed.success ? parsed.data.steps?.[0]?.depositAddress : void 0;
+  const quotedOut = parsed.success ? parsed.data.details?.currencyOut?.amount : void 0;
+  if (!parsed.success || !depositAddress || !quotedOut) {
+    throw new Error("Relay quote response missing or malformed requestId/depositAddress/amount");
+  }
+  return {
+    requestId: parsed.data.requestId,
+    depositAddress,
+    amountInBaseUnits: request.amountBaseUnits,
+    quotedOutBaseUnits: quotedOut
+  };
+}
+
+// src/commands/deposit.ts
+async function fundingOptionsFor(chainId) {
+  const [cctpRaw, relayRaw] = await Promise.all([
+    apiGet("/api/wallet/cross-chain-funding-config").catch(() => null),
+    apiGet("/api/wallet/relay-bridge-funding-config").catch(() => null)
+  ]);
+  const cctp = CrossChainFundingConfigOutputSchema.safeParse(cctpRaw);
+  const relay = RelayBridgeFundingConfigOutputSchema.safeParse(relayRaw);
+  return {
+    cctp: cctp.success && cctp.data.enabled && cctp.data.destination.chainId === chainId && cctp.data.sourceChains.length > 0 ? {
+      environment: cctp.data.environment,
+      destinationChainId: cctp.data.destination.chainId,
+      sourceChains: cctp.data.sourceChains
+    } : null,
+    relayRoutes: relay.success ? relay.data.routes.map((id) => RELAY_BRIDGE_ROUTES[id]).filter((route) => route.destination.chainId === chainId).map((route) => ({
+      routeId: route.id,
+      from: {
+        chainId: route.origin.chainId,
+        chainName: route.origin.chainName,
+        symbol: route.origin.symbol,
+        currency: route.origin.currency
+      },
+      to: {
+        chainId: route.destination.chainId,
+        chainName: route.destination.chainName,
+        symbol: route.destination.symbol
+      }
+    })) : [],
+    note: "Run `taskmarket deposit --relay-route <routeId> --amount <n>` for a Relay deposit address. Fiat funding: see issue #2720."
+  };
+}
+var depositCommand = new Command53("deposit").description(
+  "Show wallet address, network info and cross-chain funding options for the selected --network"
+).option(
+  "--relay-route <routeId>",
+  "Request a Relay deposit address for this wallet on an offered route (see fundingOptions.relayRoutes)"
+).option("--amount <amount>", "Amount of the route origin stablecoin to send, for --relay-route").action(async (opts) => {
   let address;
   try {
     address = await getWalletAddress();
@@ -3840,7 +4134,48 @@ var depositCommand = new Command53("deposit").description("Show wallet address a
     /** Kept for scripts that read it; the same address as `tokenAddress`. */
     usdcContract: tokenAddress
   };
-  printResult(data);
+  const fundingOptions = await fundingOptionsFor(chainId);
+  if (opts.relayRoute === void 0) {
+    if (opts.amount !== void 0) {
+      renderFailure(new Error("--amount needs --relay-route"));
+      return;
+    }
+    printResult({ ...data, fundingOptions });
+    return;
+  }
+  try {
+    const routeId = RelayBridgeRouteIdSchema.parse(opts.relayRoute);
+    if (!fundingOptions.relayRoutes.some((route2) => route2.routeId === routeId)) {
+      throw new Error(
+        `Relay route ${routeId} is not offered for ${chain.networkName}; offered: ${fundingOptions.relayRoutes.map((route2) => route2.routeId).join(", ") || "none"}`
+      );
+    }
+    if (opts.amount === void 0) throw new Error("--relay-route needs --amount");
+    let amountBaseUnits;
+    try {
+      amountBaseUnits = usdcToBaseUnits(opts.amount).toString();
+    } catch {
+      throw new Error("Enter a valid amount.");
+    }
+    if (BigInt(amountBaseUnits) <= 0n) throw new Error("Enter a valid amount.");
+    const deposit = await requestRelayBridgeDepositAddress({
+      routeId,
+      recipient: address,
+      amountBaseUnits
+    });
+    const route = RELAY_BRIDGE_ROUTES[routeId];
+    printResult({
+      ...data,
+      relayDeposit: {
+        routeId,
+        ...deposit,
+        send: `${opts.amount} ${route.origin.symbol} on ${route.origin.chainName} to ${deposit.depositAddress}`,
+        credits: `${route.destination.symbol} on ${route.destination.chainName} to ${address}`
+      }
+    });
+  } catch (err) {
+    renderFailure(err);
+  }
 });
 
 // src/commands/wallet/index.ts
@@ -3862,7 +4197,7 @@ var walletBalanceCommand = new Command54("balance").description("Show the wallet
 
 // src/commands/wallet/import.ts
 import { Command as Command55 } from "commander";
-import { createInterface as createInterface3 } from "readline";
+import { createInterface as createInterface4 } from "readline";
 import { privateKeyToAccount as privateKeyToAccount2 } from "viem/accounts";
 function normalizePrivateKey(raw) {
   const hex = raw.startsWith("0x") ? raw.slice(2) : raw;
@@ -3873,7 +4208,7 @@ function normalizePrivateKey(raw) {
 }
 function promptHiddenInput(prompt) {
   return new Promise((resolve) => {
-    const rl = createInterface3({
+    const rl = createInterface4({
       input: process.stdin,
       output: process.stdout,
       terminal: true
@@ -3900,9 +4235,13 @@ var walletImportCommand = new Command55("import").description("Import an existin
   "--yes",
   "Confirm legal acceptance non-interactively after reviewing every current policy"
 ).action(async (opts) => {
+  selectedNetwork();
   if (await keystoreExists()) {
     const keystore = await loadKeystore();
-    printResult({ address: keystore.walletAddress, agentId: keystore.agentId });
+    printResult({
+      address: keystore.walletAddress,
+      agentId: agentIdForChain(keystore, selectedNetwork().chainId)
+    });
     return;
   }
   let rawKey;
@@ -3950,6 +4289,7 @@ var walletImportCommand = new Command55("import").description("Import an existin
     deviceId,
     apiToken,
     agentId,
+    ...agentId ? { agentIds: { [String(selectedNetwork().chainId)]: agentId } } : {},
     keyServerUrl: apiUrl(),
     network: networkToStamp(),
     ...legalAcceptance ? {
@@ -3962,7 +4302,9 @@ var walletImportCommand = new Command55("import").description("Import an existin
     agentId = await pollAgentId(address);
     if (agentId) {
       const keystore = await loadKeystore();
-      await saveKeystore({ ...keystore, agentId });
+      await saveKeystore(
+        withAgentIdForChain({ ...keystore, agentId }, selectedNetwork().chainId, agentId)
+      );
     }
   }
   if (keySource === "flag") {
@@ -4282,7 +4624,11 @@ var withdrawDreamsCommand = new Command62("withdraw-dreams").description("Withdr
     withChainId(`/api/wallet/dreams-balance?address=${workerAddress}`)
   );
   if (!balance.hookAddress || balance.chainId === void 0) {
-    printError("DREAMS rewards are not configured on this server");
+    const chainId = selectedNetwork().chainId;
+    const chain = isTaskmarketChainId(chainId) ? taskmarketChain(chainId) : void 0;
+    printError(
+      chain && !chain.features.dreamsRewards ? `${chain.name} has no DREAMS rewards` : "DREAMS rewards are not configured on this server"
+    );
     return;
   }
   if (!isTaskmarketChainId(balance.chainId)) {
@@ -5796,6 +6142,33 @@ function sleepOrAbort(ms, signal) {
   });
 }
 var MAX_SEEN_TASK_IDS = 2e3;
+function buildDaemonTaskParams(filters, chainId) {
+  const params = new URLSearchParams();
+  params.set("status", "open");
+  params.set("limit", "50");
+  params.set("chainId", String(chainId));
+  if (typeof filters.mode === "string") {
+    params.set("mode", filters.mode);
+  }
+  const tagsValue = filters.tags;
+  if (typeof tagsValue === "string") {
+    params.set("tags", tagsValue);
+  } else if (Array.isArray(tagsValue)) {
+    params.set("tags", tagsValue.join(","));
+  }
+  return params;
+}
+function buildDaemonAuctionParams(chainId) {
+  return new URLSearchParams({
+    mode: "auction",
+    status: "open",
+    limit: "50",
+    chainId: String(chainId)
+  });
+}
+function daemonInboxPath(address, chainId) {
+  return `/api/agents/inbox?address=${encodeURIComponent(address)}&chainId=${chainId}`;
+}
 var daemonCommand = new Command69("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",
@@ -5900,24 +6273,10 @@ var daemonCommand = new Command69("daemon").description("Long-running agent daem
       const taskPollLoop = async () => {
         const knownStatuses = /* @__PURE__ */ new Map();
         const seenTaskIds = /* @__PURE__ */ new Set();
-        const buildTaskParams = () => {
-          const params = new URLSearchParams();
-          params.set("status", "open");
-          params.set("limit", "50");
-          if (typeof taskFilters.mode === "string") {
-            params.set("mode", taskFilters.mode);
-          }
-          const tagsValue = taskFilters.tags;
-          if (typeof tagsValue === "string") {
-            params.set("tags", tagsValue);
-          } else if (Array.isArray(tagsValue)) {
-            params.set("tags", tagsValue.join(","));
-          }
-          return params;
-        };
+        const buildTaskParams = () => buildDaemonTaskParams(taskFilters, selectedNetwork().chainId);
         try {
           const inbox = await apiGet(
-            `/api/agents/inbox?address=${encodeURIComponent(address)}`
+            daemonInboxPath(address, selectedNetwork().chainId)
           );
           for (const task of [...inbox.asRequester, ...inbox.asWorker]) {
             knownStatuses.set(task.id, task.status);
@@ -5937,7 +6296,7 @@ var daemonCommand = new Command69("daemon").description("Long-running agent daem
             if (stopped) break;
             try {
               const inbox = await apiGet(
-                `/api/agents/inbox?address=${encodeURIComponent(address)}`
+                daemonInboxPath(address, selectedNetwork().chainId)
               );
               const allTasks = [...inbox.asRequester, ...inbox.asWorker];
               const nextStatuses = /* @__PURE__ */ new Map();
@@ -5950,7 +6309,9 @@ var daemonCommand = new Command69("daemon").description("Long-running agent daem
                 const role = isRequester ? "requester" : "worker";
                 let pendingActions = [];
                 try {
-                  const detail = await apiGet(`/api/tasks/${change.taskId}`);
+                  const detail = await apiGet(
+                    `/api/tasks/${change.taskId}?chainId=${selectedNetwork().chainId}`
+                  );
                   pendingActions = detail.pendingActions ?? [];
                 } catch {
                 }
@@ -6025,11 +6386,7 @@ var daemonCommand = new Command69("daemon").description("Long-running agent daem
               let cursor;
               let hasMore = true;
               while (hasMore) {
-                const params = new URLSearchParams({
-                  mode: "auction",
-                  status: "open",
-                  limit: "50"
-                });
+                const params = buildDaemonAuctionParams(selectedNetwork().chainId);
                 if (cursor) params.set("cursor", cursor);
                 const result = await apiGet(`/api/tasks?${params.toString()}`);
                 for (const task of result.tasks) {
@@ -6299,8 +6656,8 @@ var browseCommand = new Command79("browse").description(
       printError("--offset must be a whole number");
       return;
     }
-    const query2 = opts.query?.trim();
-    if (query2 !== void 0 && (query2.length === 0 || query2.length > 200)) {
+    const query3 = opts.query?.trim();
+    if (query3 !== void 0 && (query3.length === 0 || query3.length > 200)) {
       printError("--query must be 1 to 200 characters");
       return;
     }
@@ -6310,7 +6667,7 @@ var browseCommand = new Command79("browse").description(
       offset: String(offset)
     });
     if (opts.status) params.set("status", opts.status);
-    if (query2) params.set("query", query2);
+    if (query3) params.set("query", query3);
     try {
       printResult(await apiGet(`/api/bug-tracker?${params.toString()}`));
     } catch (error) {
@@ -6674,12 +7031,173 @@ bugCommand.addCommand(meTooCommand);
 bugCommand.addCommand(commentCommand);
 bugCommand.addCommand(visibilityCommand);
 
-// src/commands/requester/index.ts
+// src/commands/bookmark/index.ts
 import { Command as Command89 } from "commander";
 
-// src/commands/requester/stats.ts
+// src/commands/bookmark/auth.ts
+async function bookmarkAuth(action) {
+  const auth = await signReadAuth();
+  if (!auth || Object.keys(auth.headers).length === 0) {
+    printError(`${action} needs a wallet. Run \`taskmarket init\` first.`);
+    return null;
+  }
+  return auth;
+}
+
+// src/commands/bookmark/collection.ts
 import { Command as Command88 } from "commander";
-var requesterStatsCmd = new Command88("stats").description("Get requester reputation stats for an address").argument("<address>", "Wallet address of the requester").action(async (address) => {
+var createCommand = new Command88("create").description("Create a private collection").argument("<name>", "Collection name, up to 120 characters").action(async (name) => {
+  const trimmed = name.trim();
+  if (trimmed.length === 0 || trimmed.length > 120) {
+    printError("Collection name must be 1 to 120 characters");
+    return;
+  }
+  const auth = await bookmarkAuth("Creating a collection");
+  if (!auth) return;
+  try {
+    const { data, idempotencyKey } = await apiPost(
+      "/api/bookmarks/collections",
+      { name: trimmed },
+      { headers: auth.headers }
+    );
+    printResult(data, { idempotencyKey });
+  } catch (error) {
+    return renderFailure(error);
+  }
+});
+var listCommand2 = new Command88("list").description("List your collections; a published one carries its publishedSlug (/c/<slug>)").action(async () => {
+  const auth = await bookmarkAuth("Listing collections");
+  if (!auth) return;
+  try {
+    printResult(await apiGet("/api/bookmarks/collections", { headers: auth.headers }));
+  } catch (error) {
+    return renderFailure(error);
+  }
+});
+function publishToggle(name, description, action) {
+  return new Command88(name).description(description).argument("<collection-id>", "Collection id (from `taskmarket bookmark collection list`)").action(async (collectionId) => {
+    const auth = await bookmarkAuth(action);
+    if (!auth) return;
+    try {
+      const { data, idempotencyKey } = await apiPost(
+        `/api/bookmarks/collections/${encodeURIComponent(collectionId)}/${name}`,
+        {},
+        { headers: auth.headers }
+      );
+      printResult(data, { idempotencyKey });
+    } catch (error) {
+      return renderFailure(error);
+    }
+  });
+}
+var collectionCommand = new Command88("collection").description(
+  "Create, list, publish and unpublish bookmark collections"
+);
+collectionCommand.addCommand(createCommand);
+collectionCommand.addCommand(listCommand2);
+collectionCommand.addCommand(
+  publishToggle(
+    "publish",
+    "Publish a collection at a random /c/<slug> link; viewers see only what they may see",
+    "Publishing a collection"
+  )
+);
+collectionCommand.addCommand(
+  publishToggle(
+    "unpublish",
+    "Unpublish a collection; its link stops working and is never reissued",
+    "Unpublishing a collection"
+  )
+);
+
+// src/commands/bookmark/index.ts
+var ENTITY_TYPES = ["task", "submission", "agent"];
+function parseEntityType(value, flag) {
+  if (value === void 0) return null;
+  if (ENTITY_TYPES.includes(value)) return value;
+  printError(`${flag} must be one of ${ENTITY_TYPES.join(", ")}`);
+  return null;
+}
+function chainFor(entityType) {
+  return entityType === "agent" ? { chainId: selectedNetwork().chainId } : {};
+}
+var addCommand = new Command89("add").description(
+  "Bookmark a task, submission or agent; an agent is saved on the selected network (--network)"
+).argument("<type>", `What to bookmark: ${ENTITY_TYPES.join(", ")}`).argument("<id>", "Task id, submission id or agent id").option("--collection <id>", "Save it to one of your collections (moves an existing bookmark)").option("--note <text>", "A private note, up to 500 characters").action(async (type, id, opts) => {
+  const entityType = parseEntityType(type, "<type>");
+  if (!entityType) return;
+  if (opts.note !== void 0 && opts.note.length > 500) {
+    printError("--note must be at most 500 characters");
+    return;
+  }
+  const auth = await bookmarkAuth("Bookmarking");
+  if (!auth) return;
+  try {
+    const { data, idempotencyKey } = await apiPost(
+      "/api/bookmarks",
+      {
+        entityType,
+        entityId: id,
+        ...chainFor(entityType),
+        ...opts.collection !== void 0 ? { collectionId: opts.collection } : {},
+        ...opts.note !== void 0 ? { note: opts.note } : {}
+      },
+      { headers: auth.headers }
+    );
+    printResult(data, { idempotencyKey });
+  } catch (error) {
+    return renderFailure(error);
+  }
+});
+var removeCommand = new Command89("remove").description("Remove a bookmark; an agent bookmark is matched on the selected network").argument("<type>", `What was bookmarked: ${ENTITY_TYPES.join(", ")}`).argument("<id>", "Task id, submission id or agent id").action(async (type, id) => {
+  const entityType = parseEntityType(type, "<type>");
+  if (!entityType) return;
+  const auth = await bookmarkAuth("Removing a bookmark");
+  if (!auth) return;
+  try {
+    const { data, idempotencyKey } = await apiPost(
+      "/api/bookmarks/remove",
+      { entityType, entityId: id, ...chainFor(entityType) },
+      { headers: auth.headers }
+    );
+    printResult(data, { idempotencyKey });
+  } catch (error) {
+    return renderFailure(error);
+  }
+});
+var listCommand3 = new Command89("list").description("List your bookmarks, newest first; agent entries carry their chainId").option("--type <type>", `Only one kind: ${ENTITY_TYPES.join(", ")}`).option("--collection <id>", "Only bookmarks in this collection").option("--limit <n>", "Maximum bookmarks to return (1-100)", "50").action(async (opts) => {
+  const entityType = opts.type === void 0 ? void 0 : parseEntityType(opts.type, "--type");
+  if (entityType === null) 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 bookmarkAuth("Listing bookmarks");
+  if (!auth) return;
+  const params = new URLSearchParams({ limit: String(limit) });
+  if (entityType) params.set("entityType", entityType);
+  if (opts.collection) params.set("collectionId", opts.collection);
+  try {
+    printResult(await apiGet(`/api/bookmarks?${params.toString()}`, { headers: auth.headers }));
+  } catch (error) {
+    return renderFailure(error);
+  }
+});
+var bookmarkCommand = new Command89("bookmark").description(
+  "Save tasks, submissions and agents to your private list, and share collections of them"
+);
+bookmarkCommand.addCommand(addCommand);
+bookmarkCommand.addCommand(removeCommand);
+bookmarkCommand.addCommand(listCommand3);
+bookmarkCommand.addCommand(collectionCommand);
+
+// src/commands/requester/index.ts
+import { Command as Command91 } from "commander";
+
+// src/commands/requester/stats.ts
+import { Command as Command90 } from "commander";
+var requesterStatsCmd = new Command90("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;
@@ -6693,14 +7211,14 @@ var requesterStatsCmd = new Command88("stats").description("Get requester reputa
 });
 
 // src/commands/requester/index.ts
-var requesterCmd = new Command89("requester").description("Requester reputation commands").addCommand(requesterStatsCmd);
+var requesterCmd = new Command91("requester").description("Requester reputation commands").addCommand(requesterStatsCmd);
 
 // src/commands/x402/index.ts
-import { Command as Command93 } from "commander";
+import { Command as Command95 } from "commander";
 
 // src/commands/x402/payments.ts
-import { Command as Command90, Option as Option4 } from "commander";
-import { createInterface as createInterface4 } from "readline";
+import { Command as Command92, Option as Option4 } from "commander";
+import { createInterface as createInterface5 } from "readline";
 var PAYMENT_STATES = [
   "reserved",
   "approval_pending",
@@ -6715,7 +7233,7 @@ var PAYMENT_STATES = [
 ];
 async function confirmManualResolution() {
   if (!process.stdin.isTTY) throw new Error("Manual resolution requires an interactive TTY");
-  const readline = createInterface4({ input: process.stdin, output: process.stderr });
+  const readline = createInterface5({ input: process.stdin, output: process.stderr });
   const answer = await new Promise(
     (resolve) => readline.question(
       "Manual resolution changes local spending accounting. Type resolve to continue: ",
@@ -6725,7 +7243,7 @@ async function confirmManualResolution() {
   readline.close();
   return answer.trim().toLowerCase() === "resolve";
 }
-var x402PaymentsCommand = new Command90("payments").description(
+var x402PaymentsCommand = new Command92("payments").description(
   "Inspect and reconcile X402 Pay payment records"
 );
 x402PaymentsCommand.command("list").description("List current payment records").addOption(new Option4("--state <state>", "Filter by state").choices(PAYMENT_STATES)).action(async (options) => {
@@ -6754,8 +7272,8 @@ x402PaymentsCommand.command("resolve").description("Manually record an externall
 
 // src/commands/x402/policy.ts
 import { promises as fs4 } from "fs";
-import { Command as Command91 } from "commander";
-import { createInterface as createInterface5 } from "readline";
+import { Command as Command93 } from "commander";
+import { createInterface as createInterface6 } from "readline";
 async function confirmUnattendedRule(rule) {
   if (!process.stdin.isTTY) {
     throw new Error("Authorizing an unattended policy rule requires an interactive TTY");
@@ -6773,14 +7291,14 @@ async function confirmUnattendedRule(rule) {
     ].join("\n")}
 `
   );
-  const readline = createInterface5({ input: process.stdin, output: process.stderr });
+  const readline = createInterface6({ input: process.stdin, output: process.stderr });
   const answer = await new Promise(
     (resolve) => readline.question("Type authorize to grant unattended spending: ", resolve)
   );
   readline.close();
   return answer.trim().toLowerCase() === "authorize";
 }
-var x402PolicyCommand = new Command91("policy").description(
+var x402PolicyCommand = new Command93("policy").description(
   "Manage local X402 Pay spending policy"
 );
 x402PolicyCommand.command("init").description("Create a deny-all policy file").action(async () => {
@@ -6816,14 +7334,14 @@ for (const enabled of [true, false]) {
 }
 
 // src/commands/x402/request.ts
-import { Command as Command92, Option as Option5 } from "commander";
+import { Command as Command94, 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 Command92("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(
+var x402RequestCommand = new Command94("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)",
   collect3,
@@ -6871,7 +7389,7 @@ var x402RequestCommand = new Command92("request").description("Request and pay f
 );
 
 // src/commands/x402/index.ts
-var x402Command = new Command93("x402").description(
+var x402Command = new Command95("x402").description(
   "Pay x402 services with local spending policies (X402 Pay)"
 );
 x402Command.addCommand(x402RequestCommand);
@@ -6879,10 +7397,10 @@ x402Command.addCommand(x402PolicyCommand);
 x402Command.addCommand(x402PaymentsCommand);
 
 // src/commands/sponsored-task/index.ts
-import { Command as Command108 } from "commander";
+import { Command as Command110 } from "commander";
 
 // src/commands/sponsored-task/create.ts
-import { Command as Command94 } from "commander";
+import { Command as Command96 } from "commander";
 import { toHex as toHex4 } from "viem";
 
 // ../../packages/contracts/abi/generated/SponsoredTasksVault.ts
@@ -10104,7 +10622,7 @@ async function approveSponsoredTaskSpend(input) {
 function isValidAddress4(addr) {
   return /^0x[a-fA-F0-9]{40}$/.test(addr);
 }
-var sponsoredTaskCreateCommand = new Command94("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 Command96("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;
@@ -10141,11 +10659,11 @@ var sponsoredTaskCreateCommand = new Command94("create").description("Create a n
 });
 
 // src/commands/sponsored-task/fund.ts
-import { Command as Command95 } from "commander";
+import { Command as Command97 } from "commander";
 function isValidAddress5(addr) {
   return /^0x[a-fA-F0-9]{40}$/.test(addr);
 }
-var sponsoredTaskFundCommand = new Command95("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 Command97("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;
@@ -10184,7 +10702,7 @@ var sponsoredTaskFundCommand = new Command95("fund").description("Fund a Sponsor
 });
 
 // src/commands/sponsored-task/managers.ts
-import { Command as Command96 } from "commander";
+import { Command as Command98 } from "commander";
 function isValidAddress6(addr) {
   return /^0x[a-fA-F0-9]{40}$/.test(addr);
 }
@@ -10230,7 +10748,7 @@ async function configure(opts) {
   });
   printResult({ txHash, manager: opts.manager, spendCap: cap.toString(), active: opts.active });
 }
-var sponsoredTaskManagersCommand = new Command96("managers").description(
+var sponsoredTaskManagersCommand = new Command98("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 }));
@@ -10241,8 +10759,8 @@ sponsoredTaskManagersCommand.command("list").description("List a vault authorize
 });
 
 // src/commands/sponsored-task/managed.ts
-import { Command as Command97 } from "commander";
-var sponsoredTaskManagedCommand = new Command97("managed").description(
+import { Command as Command99 } from "commander";
+var sponsoredTaskManagedCommand = new Command99("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;
@@ -10272,7 +10790,7 @@ var sponsoredTaskManagedCommand = new Command97("managed").description(
 });
 
 // src/commands/sponsored-task/fee-bank.ts
-import { Command as Command98 } from "commander";
+import { Command as Command100 } from "commander";
 function isValidAddress7(addr) {
   return /^0x[a-fA-F0-9]{40}$/.test(addr);
 }
@@ -10284,7 +10802,7 @@ async function requireKeystore2() {
     return null;
   }
 }
-var sponsoredTaskFeeBankCommand = new Command98("fee-bank").description(
+var sponsoredTaskFeeBankCommand = new Command100("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) => {
@@ -10368,8 +10886,8 @@ sponsoredTaskFeeBankCommand.command("withdraw").description("Withdraw unused USD
 );
 
 // src/commands/sponsored-task/list.ts
-import { Command as Command99 } from "commander";
-var sponsoredTaskListCommand = new Command99("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 Command101 } from "commander";
+var sponsoredTaskListCommand = new Command101("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");
@@ -10378,8 +10896,8 @@ var sponsoredTaskListCommand = new Command99("list").description("List Sponsored
 });
 
 // src/commands/sponsored-task/settlements.ts
-import { Command as Command100 } from "commander";
-var sponsoredTaskSettlementsCommand = new Command100("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 Command102 } from "commander";
+var sponsoredTaskSettlementsCommand = new Command102("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");
@@ -10394,17 +10912,17 @@ var sponsoredTaskSettlementsCommand = new Command100("settlements").description(
 });
 
 // src/commands/sponsored-task/show.ts
-import { Command as Command101 } from "commander";
-var sponsoredTaskShowCommand = new Command101("show").description("Show a Sponsored Task vault by id").argument("<vaultId>", "Vault id").action(async (vaultId) => {
+import { Command as Command103 } from "commander";
+var sponsoredTaskShowCommand = new Command103("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 randomBytes3 } from "crypto";
-import { Command as Command102 } from "commander";
+import { Command as Command104 } from "commander";
 var REQUEST_TTL_SECONDS = 5 * 60;
-var sponsoredTaskRequestReviewCommand = new Command102("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 Command104("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();
@@ -10461,18 +10979,18 @@ var sponsoredTaskRequestReviewCommand = new Command102("request-review").descrip
 });
 
 // src/commands/sponsored-task/balance.ts
-import { Command as Command103 } from "commander";
-var sponsoredTaskBalanceCommand = new Command103("balance").description("Show a Sponsored Task vault funded/available/reserved balances").argument("<vaultId>", "Vault id").action(async (vaultId) => {
+import { Command as Command105 } from "commander";
+var sponsoredTaskBalanceCommand = new Command105("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 Command104 } from "commander";
+import { Command as Command106 } from "commander";
 function isValidAddress8(addr) {
   return /^0x[a-fA-F0-9]{40}$/.test(addr);
 }
-var sponsoredTaskWithdrawCommand = new Command104("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 Command106("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;
@@ -10502,11 +11020,11 @@ var sponsoredTaskWithdrawCommand = new Command104("withdraw").description("Withd
 });
 
 // src/commands/sponsored-task/exit.ts
-import { Command as Command105 } from "commander";
+import { Command as Command107 } from "commander";
 function isValidAddress9(addr) {
   return /^0x[a-fA-F0-9]{40}$/.test(addr);
 }
-var sponsoredTaskExitCommand = new Command105("exit").description(
+var sponsoredTaskExitCommand = new Command107("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)) {
@@ -10542,7 +11060,7 @@ var sponsoredTaskExitCommand = new Command105("exit").description(
 });
 
 // src/commands/sponsored-task/claim.ts
-import { Command as Command106 } from "commander";
+import { Command as Command108 } from "commander";
 var CLAIM_TO_TYPES = {
   ClaimTo: [
     { name: "vaultId", type: "bytes32" },
@@ -10577,7 +11095,7 @@ async function postClaimWithRetry(path3, body, options = {}) {
     }
   }
 }
-var sponsoredTaskClaimCommand = new Command106("claim").description("Claim your unclaimed Sponsored Task reward for a vault task").argument("<vaultId>", "Vault id").option(
+var sponsoredTaskClaimCommand = new Command108("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) => {
@@ -10669,10 +11187,10 @@ var sponsoredTaskClaimCommand = new Command106("claim").description("Claim your
 });
 
 // src/commands/sponsored-task/rewards.ts
-import { Command as Command107 } from "commander";
+import { Command as Command109 } from "commander";
 var REWARD_STATES = SponsoredTaskRewardStateSchema.options;
 var CLAIM_STATUSES = SponsoredTaskWorkerRewardClaimStatusSchema.options;
-var sponsoredTaskRewardsCommand = new Command107("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 Command109("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) {
@@ -10712,7 +11230,7 @@ var sponsoredTaskRewardsCommand = new Command107("rewards").description("List Sp
 );
 
 // src/commands/sponsored-task/index.ts
-var sponsoredTaskCommand = new Command108("sponsored-task").description(
+var sponsoredTaskCommand = new Command110("sponsored-task").description(
   "Sponsored Task vault administration and reward claims"
 );
 sponsoredTaskCommand.addCommand(sponsoredTaskCreateCommand);
@@ -10730,15 +11248,122 @@ sponsoredTaskCommand.addCommand(sponsoredTaskExitCommand);
 sponsoredTaskCommand.addCommand(sponsoredTaskClaimCommand);
 sponsoredTaskCommand.addCommand(sponsoredTaskRewardsCommand);
 
+// src/commands/drops.ts
+import { Command as Command111 } from "commander";
+var listCommand4 = new Command111("list").description("List public Task Drops, ones accepting work first").option("--limit <n>", "Maximum drops to return (1-48)", "24").option("--cursor <cursor>", "nextCursor from a previous page").action(async (opts) => {
+  try {
+    const input = parseInput(TaskDropDirectoryInputSchema, {
+      limit: optionalInt(opts.limit),
+      cursor: opts.cursor
+    });
+    const params = new URLSearchParams({ limit: String(input.limit) });
+    if (input.cursor) params.set("cursor", input.cursor);
+    printResult(await apiGet(`/api/task-drops/directory?${params.toString()}`));
+  } catch (err) {
+    renderFailure(err);
+  }
+});
+var showCommand2 = new Command111("show").description("Show a Task Drop and its discoverable tasks").argument("<taskDropId>", "Task Drop ID").action(async (taskDropId) => {
+  try {
+    const input = parseInput(TaskDropGetInputSchema, { taskDropId });
+    const result = await apiGet(`/api/task-drops/${encodeURIComponent(input.taskDropId)}`);
+    if (result === null || result === void 0) {
+      throw new Error(`Task Drop ${input.taskDropId} not found`);
+    }
+    printResult(result);
+  } catch (err) {
+    renderFailure(err);
+  }
+});
+var subscribeCommand = new Command111("subscribe").description("Subscribe an email to one Task Drop, or with --official to every official drop").argument("[taskDropId]", "Task Drop ID (omit with --official)").requiredOption("--email <email>", "Email address to notify").option("--official", "Subscribe to all official Task Drops").option("--wallet <address>", "Wallet address to associate with the subscription").action(
+  async (taskDropId, opts) => {
+    try {
+      if (opts.official) {
+        if (taskDropId) throw new Error("Pass either a Task Drop ID or --official, not both");
+        const body2 = parseInput(TaskDropOfficialSubscribeInputSchema, {
+          email: opts.email,
+          walletAddress: opts.wallet,
+          source: "cli"
+        });
+        const outcome2 = await apiPost("/api/task-drops/official/subscribe", body2);
+        printResult(outcome2.data, { idempotencyKey: outcome2.idempotencyKey });
+        return;
+      }
+      if (!taskDropId) throw new Error("Pass a Task Drop ID, or --official");
+      const body = parseInput(TaskDropSubscribeInputSchema, {
+        taskDropId,
+        email: opts.email,
+        walletAddress: opts.wallet,
+        source: "cli"
+      });
+      const outcome = await apiPost("/api/task-drops/subscribe", body);
+      printResult(outcome.data, { idempotencyKey: outcome.idempotencyKey });
+    } catch (err) {
+      renderFailure(err);
+    }
+  }
+);
+var statusCommand3 = new Command111("status").description("Check whether an email is subscribed to a Task Drop, or with --official to all").argument("[taskDropId]", "Task Drop ID (omit with --official)").requiredOption("--email <email>", "Email address to check").option("--official", "Check the all-official-drops subscription").action(async (taskDropId, opts) => {
+  try {
+    if (opts.official) {
+      if (taskDropId) throw new Error("Pass either a Task Drop ID or --official, not both");
+      const input2 = parseInput(TaskDropOfficialStatusInputSchema, { email: opts.email });
+      const params2 = new URLSearchParams({ email: input2.email });
+      printResult(await apiGet(`/api/task-drops/official/status?${params2.toString()}`));
+      return;
+    }
+    if (!taskDropId) throw new Error("Pass a Task Drop ID, or --official");
+    const input = parseInput(TaskDropStatusInputSchema, { taskDropId, email: opts.email });
+    const params = new URLSearchParams({ taskDropId: input.taskDropId, email: input.email });
+    printResult(await apiGet(`/api/task-drops/status?${params.toString()}`));
+  } catch (err) {
+    renderFailure(err);
+  }
+});
+var dropsCommand = new Command111("drops").description("Browse Task Drops and manage email subscriptions to them").addCommand(listCommand4).addCommand(showCommand2).addCommand(subscribeCommand).addCommand(statusCommand3);
+
+// src/commands/hooks.ts
+import { Command as Command112 } from "commander";
+var listCommand5 = new Command112("list").description("List observed hooks and their active-phase task counts on the selected --network").option("--limit <n>", "Maximum hooks to return (1-100)", "50").action(async (opts) => {
+  try {
+    const input = parseInput(HookIndexInputSchema, { limit: optionalInt(opts.limit) });
+    printResult(await apiGet(withChainId(`/api/hooks?limit=${input.limit}`)));
+  } catch (err) {
+    renderFailure(err);
+  }
+});
+var showCommand3 = new Command112("show").description("Show one observed hook by address on the selected --network").argument("<address>", "Hook contract address").action(async (address) => {
+  try {
+    const input = parseInput(HookGetInputSchema, { address });
+    const result = await apiGet(withChainId(`/api/hooks/${input.address}`));
+    if (result === null || result === void 0) {
+      throw new Error(`Hook ${input.address} has not been observed on this network`);
+    }
+    printResult(result);
+  } catch (err) {
+    renderFailure(err);
+  }
+});
+var attachmentConfigCommand = new Command112("attachment-config").description(
+  "Show the protocol-default hook order and maximum hooks per task on the selected --network"
+).action(async () => {
+  try {
+    printResult(await apiGet(withChainId("/api/hooks/attachment-configuration")));
+  } catch (err) {
+    renderFailure(err);
+  }
+});
+var hooksCommand = new Command112("hooks").description("Browse the hook registry on the selected --network").addCommand(listCommand5).addCommand(showCommand3).addCommand(attachmentConfigCommand);
+
 // src/index.ts
 var require2 = createRequire(import.meta.url);
 var { version } = require2("../package.json");
-var program = new Command109();
+var program = new Command113();
 setLastErrorCliVersion(version);
 program.name("taskmarket").description("Taskmarket CLI for AI agents").version(version);
 program.option(
   "--network <name>",
-  `Network to use: ${NETWORK_NAMES.join(", ")} (default: TASKMARKET_NETWORK, then the keystore's network, then base)`
+  `Network to use: ${NETWORK_NAMES.join(", ")} (else TASKMARKET_NETWORK, then the keystore's network; there is no default)`
 ).hook("preAction", async (thisCommand) => {
   const { network } = thisCommand.opts();
   setSelectedNetwork(
@@ -10771,7 +11396,10 @@ program.addCommand(requesterCmd);
 program.addCommand(legalCommand);
 program.addCommand(x402Command);
 program.addCommand(sponsoredTaskCommand);
+program.addCommand(dropsCommand);
+program.addCommand(hooksCommand);
 program.addCommand(bugCommand);
+program.addCommand(bookmarkCommand);
 void (async () => {
   try {
     await program.parseAsync(process.argv);