@lucid-agents/taskmarket 1.21.0 → 1.22.0

package/dist/index.js

@@ -14,7 +14,7 @@ import {
   signReadAuth,
   submitTaskFiles,
   taskAccessGrantHeaders
-} from "./chunk-5N25NATR.js";
+} from "./chunk-7MXTPGES.js";
 import {
   ComputeCreditError,
   applyComputeCreditSetup,
@@ -36,7 +36,7 @@ import {
   refusedPaidWrite,
   releasePendingComputePurchase,
   resolvePendingComputePurchases
-} from "./chunk-TAMXCFLT.js";
+} from "./chunk-RSSJD6JU.js";
 import {
   MPP_TEMPO_DEFAULT_VALIDITY_SECONDS,
   X402PayError,
@@ -58,17 +58,25 @@ import {
   signSponsoredTempoTransfer,
   signTaskmarketFeePayment,
   signTypedData
-} from "./chunk-HE2N4GEO.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,
@@ -78,11 +86,15 @@ import {
   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,
@@ -103,6 +115,12 @@ import {
   SubmissionReviewStartPayloadSchema,
   SubmissionReviewTaskInputSchema,
   SubmitBugReportInputSchema,
+  TaskDropDirectoryInputSchema,
+  TaskDropGetInputSchema,
+  TaskDropOfficialStatusInputSchema,
+  TaskDropOfficialSubscribeInputSchema,
+  TaskDropStatusInputSchema,
+  TaskDropSubscribeInputSchema,
   TaskTermsError,
   TermsPresetName,
   WALLET_BRIDGE_ORIGIN_CHAIN_ID,
@@ -131,6 +149,7 @@ import {
   chainInfoFor,
   claimStakeToPost,
   clientValidityWindowSeconds,
+  createKeystore,
   decryptPrivateKey,
   dreamsToUsd,
   encryptPrivateKey,
@@ -157,6 +176,7 @@ import {
   readFailureBody,
   readKeystoreNetwork,
   redactSecrets,
+  relayBridgeRoute,
   resolveIdempotencyKey,
   resolveNetwork,
   resolveTaskTerms,
@@ -172,14 +192,14 @@ import {
   withChainId,
   withErrorContext,
   withIdempotentWrite
-} from "./chunk-3IIVNF5F.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
@@ -369,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";
@@ -692,7 +734,7 @@ var initCommand = new Command2("init").description(
   });
   const encryptedKey = encryptPrivateKey(deviceEncryptionKey, privateKey);
   let agentId = initialAgentId;
-  await saveKeystore({
+  const newKeystore = {
     encryptedKey,
     walletAddress: address,
     deviceId,
@@ -706,7 +748,18 @@ var initCommand = new Command2("init").description(
       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) {
@@ -762,11 +815,26 @@ identityCommand.command("register").description(
     printResult({ agentId: stored, alreadyRegistered: true, chainId });
     return;
   }
-  const { data, idempotencyKey } = await apiPost(`/api/devices/${encodeURIComponent(keystore.deviceId)}/identity`, {
-    deviceId: keystore.deviceId,
-    apiToken: keystore.apiToken,
-    chainId
-  });
+  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 error;
+  }
+  const { data, idempotencyKey } = posted;
   const agentId = data.agentId ?? await pollAgentId(keystore.walletAddress);
   if (agentId) {
     await saveKeystore(withAgentIdForChain(await loadKeystore(), chainId, agentId));
@@ -840,7 +908,91 @@ var whoamiCommand = new Command5("whoami").description(
 
 // src/commands/stats.ts
 import { Command as Command6 } from "commander";
-var statsCommand = new Command6("stats").description("View agent statistics on the selected --network").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();
@@ -883,7 +1035,12 @@ var statsCommand = new Command6("stats").description("View agent statistics on t
     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
@@ -908,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));
@@ -968,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
       );
     },
@@ -1011,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
       );
     },
@@ -1035,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
       );
     },
@@ -1067,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
       );
     },
@@ -3487,7 +3644,7 @@ async function runAgentCommand(options) {
   try {
     const { assertAgentCompatibility } = await import("./compatibility-636WJOEX.js");
     const pi = assertAgentCompatibility();
-    const { runAgent } = await import("./launch-QDCWAIKE.js");
+    const { runAgent } = await import("./launch-UUW34PHS.js");
     result = await runAgent({
       model: options.model,
       pi,
@@ -3546,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-FTTQWS5P.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-26YOWQOH.js");
+    const { runDoctor, doctorLines } = await import("./doctor-MZUDBF4B.js");
     const report = await run(options, () => runDoctor(), doctorLines);
     if (report && !report.ok) process.exitCode = 1;
   });
@@ -3563,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-MALCM3NB.js");
+      const { reconcileChannelPurchases, reconcileInvocation } = await import("./reconcile-NDPFPJEB.js");
       const choice = { rail: options.rail, channel: options.channel };
       if (invocationId !== void 0) {
         await run(
@@ -3621,7 +3778,7 @@ function agentManagementCommands() {
             `Not a USDC amount: ${options.amount} (digits, at most 6 decimals)`
           );
         }
-        const { openAgentChannels, requestTopUp, selectRail, withdrawalHatch } = await import("./channels-OBJUNCZX.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 {
@@ -3645,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-OBJUNCZX.js");
-        const { reconcileLeasedPurchase } = await import("./reconcile-MALCM3NB.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(
@@ -3717,7 +3874,7 @@ function agentManagementCommands() {
         options,
         async () => {
           await requireExperimental();
-          const { runPull } = await import("./sync-pull-N6OTHBWR.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,
@@ -3780,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 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").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";
@@ -3830,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();
@@ -3870,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
@@ -3930,6 +4235,7 @@ 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({
@@ -6350,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;
     }
@@ -6361,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) {
@@ -6725,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;
@@ -6744,13 +7211,13 @@ 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 { Command as Command92, Option as Option4 } from "commander";
 import { createInterface as createInterface5 } from "readline";
 var PAYMENT_STATES = [
   "reserved",
@@ -6776,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) => {
@@ -6805,7 +7272,7 @@ 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 { Command as Command93 } from "commander";
 import { createInterface as createInterface6 } from "readline";
 async function confirmUnattendedRule(rule) {
   if (!process.stdin.isTTY) {
@@ -6831,7 +7298,7 @@ async function confirmUnattendedRule(rule) {
   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 () => {
@@ -6867,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,
@@ -6922,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);
@@ -6930,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
@@ -10155,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;
@@ -10192,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;
@@ -10235,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);
 }
@@ -10281,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 }));
@@ -10292,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;
@@ -10323,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);
 }
@@ -10335,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) => {
@@ -10419,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");
@@ -10429,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");
@@ -10445,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();
@@ -10512,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;
@@ -10553,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)) {
@@ -10593,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" },
@@ -10628,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) => {
@@ -10720,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) {
@@ -10763,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);
@@ -10781,10 +11248,117 @@ 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(
@@ -10822,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);