@lucid-agents/taskmarket 1.12.1 → 1.13.0

package/dist/index.js

@@ -32,7 +32,7 @@ function csvArrayQueryParam(schema = z.string()) {
 }
 
 // ../../packages/shared/dist/schemas/task.schemas.js
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
 
 // ../../packages/shared/dist/schemas/task-drops.schemas.js
 import { z as z2 } from "zod";
@@ -155,12 +155,42 @@ var TaskDropDirectoryResponseSchema = z2.object({
   nextCursor: z2.string().nullable()
 });
 
+// ../../packages/shared/dist/schemas/hook.schemas.js
+import { z as z3 } from "zod";
+var HookAddressSchema = z3.string().regex(/^0x(?!0{40}$)[a-fA-F0-9]{40}$/, "Hook address must be a non-zero 20-byte hex address");
+var HookTaskModeSchema = z3.enum(["bounty", "claim", "pitch", "benchmark", "auction"]);
+var HookIndexInputSchema = z3.object({
+  limit: z3.number().int().min(1).max(100).optional().default(50)
+});
+var HookGetInputSchema = z3.object({
+  address: HookAddressSchema
+});
+var HookIndexEntrySchema = z3.object({
+  address: HookAddressSchema,
+  activePhaseTaskCount: z3.number().int().nonnegative(),
+  // The observation is scoped to the configured Taskmarket deployment. Clients must not infer
+  // that an address observed on one Base network is evidence for the same address on another.
+  chainId: z3.number().int().positive(),
+  modes: z3.array(HookTaskModeSchema).max(5).refine((modes) => new Set(modes).size === modes.length, "Hook modes must be distinct"),
+  taskCount: z3.number().int().nonnegative(),
+  taskIds: z3.array(z3.string()).max(8)
+});
+var HookIndexResponseSchema = z3.object({
+  hooks: z3.array(HookIndexEntrySchema).max(100),
+  hasMore: z3.boolean(),
+  observation: z3.literal("ordered-hook-registered-task-associations")
+});
+var HookAttachmentConfigurationSchema = z3.object({
+  defaultHooks: z3.array(HookAddressSchema).max(8).nullable(),
+  maxHooks: z3.literal(8)
+});
+
 // ../../packages/shared/dist/schemas/task.schemas.js
 var TASK_DESCRIPTION_MAX_LENGTH = 1e4;
-var TaskMode = z3.enum(["bounty", "claim", "pitch", "benchmark", "auction"]);
-var TaskVisibility = z3.enum(["unlisted", "public", "private"]);
-var SubmissionVisibility = z3.enum(["public", "reveal_all", "winner_only", "never"]);
-var TaskStatus = z3.enum([
+var TaskMode = z4.enum(["bounty", "claim", "pitch", "benchmark", "auction"]);
+var TaskVisibility = z4.enum(["unlisted", "public", "private"]);
+var SubmissionVisibility = z4.enum(["public", "reveal_all", "winner_only", "never"]);
+var TaskStatus = z4.enum([
   "open",
   "claimed",
   "worker_selected",
@@ -172,9 +202,9 @@ var TaskStatus = z3.enum([
   "expired",
   "cancelled"
 ]);
-var TaskPhase = z3.enum(["active", "in_review", "awaiting_settlement", "resolved"]);
-var AuctionType = z3.enum(["dutch", "english", "reverse_dutch", "reverse_english"]);
-var PendingActionName = z3.enum([
+var TaskPhase = z4.enum(["active", "in_review", "awaiting_settlement", "resolved"]);
+var AuctionType = z4.enum(["dutch", "english", "reverse_dutch", "reverse_english"]);
+var PendingActionName = z4.enum([
   "accept",
   "accept_submissions",
   "appeal",
@@ -197,70 +227,90 @@ var PendingActionName = z3.enum([
   "submit_proof",
   "update"
 ]);
-var PendingActionSchema = z3.object({
-  role: z3.enum(["requester", "worker", "evaluator", "dispute_resolver", "anyone"]),
+var PendingActionSchema = z4.object({
+  role: z4.enum(["requester", "worker", "evaluator", "dispute_resolver", "anyone"]),
   action: PendingActionName,
-  command: z3.string(),
-  eligibleAddress: z3.string().nullable().optional(),
-  requiresPayment: z3.boolean().optional(),
-  paymentAmount: z3.string().nullable().optional(),
-  availableAfter: z3.string().nullable().optional(),
-  availableUntil: z3.string().nullable().optional(),
-  targetWorker: z3.string().nullable().optional()
-});
-var TaskAwardSchema = z3.object({
-  workerAddress: z3.string(),
-  workerAgentId: z3.string().nullable(),
-  workerActorType: z3.enum(["agent", "human"]),
-  rank: z3.number().int().positive(),
-  isPrimary: z3.boolean(),
-  grossAmount: z3.string(),
-  workerPayment: z3.string(),
-  platformFee: z3.string(),
-  settlementTxHash: z3.string(),
-  settledAt: z3.string(),
-  rating: z3.number().min(0).max(100).nullable()
-});
-var TaskCreateSchema = z3.object({
-  description: z3.string().min(1, "Description is required").max(TASK_DESCRIPTION_MAX_LENGTH, "Description is too long"),
+  command: z4.string(),
+  eligibleAddress: z4.string().nullable().optional(),
+  requiresPayment: z4.boolean().optional(),
+  paymentAmount: z4.string().nullable().optional(),
+  availableAfter: z4.string().nullable().optional(),
+  availableUntil: z4.string().nullable().optional(),
+  targetWorker: z4.string().nullable().optional()
+});
+var TaskAwardSchema = z4.object({
+  workerAddress: z4.string(),
+  workerAgentId: z4.string().nullable(),
+  workerActorType: z4.enum(["agent", "human"]),
+  rank: z4.number().int().positive(),
+  isPrimary: z4.boolean(),
+  grossAmount: z4.string(),
+  workerPayment: z4.string(),
+  platformFee: z4.string(),
+  settlementTxHash: z4.string(),
+  settledAt: z4.string(),
+  rating: z4.number().min(0).max(100).nullable()
+});
+var TaskCreateSchema = z4.object({
+  description: z4.string().min(1, "Description is required").max(TASK_DESCRIPTION_MAX_LENGTH, "Description is too long"),
   reward: PositiveUsdcBaseUnitsSchema,
-  duration: z3.number().positive("Duration must be positive"),
-  tags: z3.array(z3.string()).max(10, "Maximum 10 tags allowed"),
+  duration: z4.number().positive("Duration must be positive"),
+  tags: z4.array(z4.string()).max(10, "Maximum 10 tags allowed"),
   mode: TaskMode.optional().default("bounty"),
   taskVisibility: TaskVisibility.optional().default("public"),
   submissionVisibility: SubmissionVisibility.optional().default("public"),
-  stakeRequired: z3.boolean().optional().default(false),
+  stakeRequired: z4.boolean().optional().default(false),
   // Integral: this is client-supplied and lands in a `uint16` on chain, where a fraction is
   // not representable at all. Without `.int()` a 12.5 was accepted here and silently became
   // something else by the time it reached the contract (ADR-0069).
-  stakeBps: z3.number().int().min(0).max(1e4).optional().default(0),
-  pitchDeadline: z3.number().positive().optional(),
-  bidDeadline: z3.number().positive().optional(),
+  stakeBps: z4.number().int().min(0).max(1e4).optional().default(0),
+  pitchDeadline: z4.number().positive().optional(),
+  bidDeadline: z4.number().positive().optional(),
   maxPrice: PositiveUsdcBaseUnitsSchema.optional(),
-  metricDescription: z3.string().max(500).optional(),
-  metricTarget: z3.string().max(200).optional(),
+  metricDescription: z4.string().max(500).optional(),
+  metricTarget: z4.string().max(200).optional(),
   auctionType: AuctionType.optional(),
   auctionStartPrice: UsdcBaseUnitsSchema.optional(),
   auctionFloorPrice: UsdcBaseUnitsSchema.optional(),
-  hookContract: z3.string().optional(),
-  hookData: z3.string().regex(/^0x(?:[0-9a-fA-F]{2})*$/, "hookData must be hex-encoded bytes (0x followed by pairs of hex digits)").optional(),
-  evaluator: z3.string().optional(),
+  // `hookContract` remains the backwards-compatible single-custom-hook input. New callers
+  // should use ordered `hookContracts`; the Diamond prepends its current default hooks.
+  hookContract: HookAddressSchema.optional(),
+  hookContracts: z4.array(HookAddressSchema).min(1).max(8).optional(),
+  hookData: z4.string().regex(/^0x(?:[0-9a-fA-F]{2})*$/, "hookData must be hex-encoded bytes (0x followed by pairs of hex digits)").optional(),
+  evaluator: z4.string().optional(),
   // Integral for the same reason as `stakeBps` above: client-supplied, `uint16` on chain.
-  evaluatorFeeBps: z3.number().int().min(0).max(1e4).optional(),
-  evaluationWindowHours: z3.number().positive().optional(),
-  appealWindowHours: z3.number().positive().optional(),
-  disputeResolver: z3.string().optional(),
-  taskDropId: z3.string().min(1).optional(),
+  evaluatorFeeBps: z4.number().int().min(0).max(1e4).optional(),
+  evaluationWindowHours: z4.number().positive().optional(),
+  appealWindowHours: z4.number().positive().optional(),
+  disputeResolver: z4.string().optional(),
+  taskDropId: z4.string().min(1).optional(),
   taskDropCreate: TaskDropCreateInlineSchema.optional(),
   // Phase 3 (ADR-0030): only meaningful when taskVisibility === 'private'. At least
   // one of the two invite mechanisms is required for a private task; either or both
   // may be provided (requester's choice).
-  allowedViewers: z3.array(z3.string()).max(50, "Maximum 50 invited wallets at creation").optional(),
-  accessPassword: z3.string().min(8, "Password must be at least 8 characters").max(200).optional()
+  allowedViewers: z4.array(z4.string()).max(50, "Maximum 50 invited wallets at creation").optional(),
+  accessPassword: z4.string().min(8, "Password must be at least 8 characters").max(200).optional()
 }).superRefine((input, ctx) => {
+  if (input.hookContract && input.hookContracts) {
+    ctx.addIssue({
+      code: z4.ZodIssueCode.custom,
+      path: ["hookContracts"],
+      message: "Provide hookContract or hookContracts, not both"
+    });
+  }
+  if (input.hookContracts) {
+    const normalized = input.hookContracts.map((hook) => hook.toLowerCase());
+    if (new Set(normalized).size !== normalized.length) {
+      ctx.addIssue({
+        code: z4.ZodIssueCode.custom,
+        path: ["hookContracts"],
+        message: "hookContracts must not contain duplicate addresses"
+      });
+    }
+  }
   if (input.taskDropId && input.taskDropCreate) {
     ctx.addIssue({
-      code: z3.ZodIssueCode.custom,
+      code: z4.ZodIssueCode.custom,
       path: ["taskDropId"],
       message: "Provide taskDropId or taskDropCreate, not both"
     });
@@ -270,7 +320,7 @@ var TaskCreateSchema = z3.object({
     const hasPassword = !!input.accessPassword;
     if (!hasViewers && !hasPassword) {
       ctx.addIssue({
-        code: z3.ZodIssueCode.custom,
+        code: z4.ZodIssueCode.custom,
         path: ["taskVisibility"],
         message: "A private task needs at least one of allowedViewers or accessPassword"
       });
@@ -278,14 +328,14 @@ var TaskCreateSchema = z3.object({
   } else {
     if (input.allowedViewers && input.allowedViewers.length > 0) {
       ctx.addIssue({
-        code: z3.ZodIssueCode.custom,
+        code: z4.ZodIssueCode.custom,
         path: ["allowedViewers"],
         message: "allowedViewers is only valid when taskVisibility is private"
       });
     }
     if (input.accessPassword) {
       ctx.addIssue({
-        code: z3.ZodIssueCode.custom,
+        code: z4.ZodIssueCode.custom,
         path: ["accessPassword"],
         message: "accessPassword is only valid when taskVisibility is private"
       });
@@ -297,20 +347,20 @@ var TaskCreateSchema = z3.object({
   const reward = toBaseUnits(input.reward);
   if (!input.maxPrice) {
     ctx.addIssue({
-      code: z3.ZodIssueCode.custom,
+      code: z4.ZodIssueCode.custom,
       path: ["maxPrice"],
       message: "maxPrice is required for auction mode"
     });
   } else if (reward !== null && toBaseUnits(input.maxPrice) !== null && toBaseUnits(input.maxPrice) !== reward) {
     ctx.addIssue({
-      code: z3.ZodIssueCode.custom,
+      code: z4.ZodIssueCode.custom,
       path: ["maxPrice"],
       message: "maxPrice must equal reward for auction mode"
     });
   }
   if (!input.auctionType) {
     ctx.addIssue({
-      code: z3.ZodIssueCode.custom,
+      code: z4.ZodIssueCode.custom,
       path: ["auctionType"],
       message: "auctionType is required for auction mode (dutch, english, reverse_dutch, reverse_english)"
     });
@@ -318,14 +368,14 @@ var TaskCreateSchema = z3.object({
   }
   if (input.auctionType === "dutch" && input.auctionFloorPrice === void 0) {
     ctx.addIssue({
-      code: z3.ZodIssueCode.custom,
+      code: z4.ZodIssueCode.custom,
       path: ["auctionFloorPrice"],
       message: "auctionFloorPrice is required for dutch auction type"
     });
   }
   if (input.auctionType === "reverse_dutch" && input.auctionStartPrice === void 0) {
     ctx.addIssue({
-      code: z3.ZodIssueCode.custom,
+      code: z4.ZodIssueCode.custom,
       path: ["auctionStartPrice"],
       message: "auctionStartPrice is required for reverse_dutch auction type"
     });
@@ -337,135 +387,135 @@ var TaskCreateSchema = z3.object({
     const parsed = toBaseUnits(value);
     if (parsed !== null && reward !== null && parsed > reward) {
       ctx.addIssue({
-        code: z3.ZodIssueCode.custom,
+        code: z4.ZodIssueCode.custom,
         path: [field],
         message: `${field} must be less than or equal to reward`
       });
     }
   }
 });
-var TaskResponseSchema = z3.object({
-  id: z3.string(),
+var TaskResponseSchema = z4.object({
+  id: z4.string(),
   // The task's public name (ADR-0098), e.g. 'TSK-4M0BXQ2E'. Nullable until the backfill in
   // migration 0051 completes; `id` remains the canonical URL segment.
-  referenceCode: z3.string().nullable().optional(),
-  requester: z3.string(),
-  requesterPubkey: z3.string().nullable(),
-  description: z3.string(),
-  reward: z3.string(),
-  escrowTxHash: z3.string(),
-  createdAt: z3.string(),
-  expiryTime: z3.string(),
+  referenceCode: z4.string().nullable().optional(),
+  requester: z4.string(),
+  requesterPubkey: z4.string().nullable(),
+  description: z4.string(),
+  reward: z4.string(),
+  escrowTxHash: z4.string(),
+  createdAt: z4.string(),
+  expiryTime: z4.string(),
   status: TaskStatus,
-  tags: z3.array(z3.string()),
+  tags: z4.array(z4.string()),
   mode: TaskMode,
   taskVisibility: TaskVisibility.optional().default("public"),
   submissionVisibility: SubmissionVisibility.optional().default("public"),
   // Phase 3 (ADR-0030): whether a private task has a password mechanism configured --
   // never the hash itself, and never returned for a non-private task.
-  hasAccessPassword: z3.boolean().optional(),
-  stakeRequired: z3.boolean(),
+  hasAccessPassword: z4.boolean().optional(),
+  stakeRequired: z4.boolean(),
   // Same shape the request side already enforces (ADR-0069): a `uint16` fraction of the escrow,
   // so the response cannot describe a stake the contract could not have held.
-  stakeBps: z3.number().int().min(0).max(1e4),
-  pitchDeadline: z3.string().nullable(),
-  bidDeadline: z3.string().nullable(),
-  maxPrice: z3.string().nullable(),
-  metricDescription: z3.string().nullable(),
-  metricTarget: z3.string().nullable(),
-  claimedBy: z3.string().nullable(),
-  claimedAt: z3.string().nullable(),
+  stakeBps: z4.number().int().min(0).max(1e4),
+  pitchDeadline: z4.string().nullable(),
+  bidDeadline: z4.string().nullable(),
+  maxPrice: z4.string().nullable(),
+  metricDescription: z4.string().nullable(),
+  metricTarget: z4.string().nullable(),
+  claimedBy: z4.string().nullable(),
+  claimedAt: z4.string().nullable(),
   // Required, never optional: this is the multiplier every net-reward figure a client shows is
   // derived from, and the column behind it has been `NOT NULL` since the first migration. A
   // reader that had to supply its own value on absence would be guessing at money.
-  platformFeeBps: z3.number().int().min(0).max(1e4),
-  submissionCount: z3.number().optional().default(0),
-  awardCount: z3.number().int().nonnegative().optional(),
+  platformFeeBps: z4.number().int().min(0).max(1e4),
+  submissionCount: z4.number().optional().default(0),
+  awardCount: z4.number().int().nonnegative().optional(),
   // Read-time projection of the rank-1 task_awards row -- not a separately
   // written field, so it cannot drift out of sync the way the old worker/
   // rating compatibility fields could (see ADR-0006). null before settlement.
-  primaryAward: z3.object({
-    workerAddress: z3.string(),
-    rating: z3.number().min(0).max(100).nullable()
+  primaryAward: z4.object({
+    workerAddress: z4.string(),
+    rating: z4.number().min(0).max(100).nullable()
   }).nullable().optional(),
-  pitchCount: z3.number().optional().default(0),
-  requesterAgentId: z3.string().nullable().optional(),
-  requesterActorType: z3.enum(["agent", "human"]).optional(),
-  workerAgentId: z3.string().nullable().optional(),
-  workerActorType: z3.enum(["agent", "human"]).optional(),
+  pitchCount: z4.number().optional().default(0),
+  requesterAgentId: z4.string().nullable().optional(),
+  requesterActorType: z4.enum(["agent", "human"]).optional(),
+  workerAgentId: z4.string().nullable().optional(),
+  workerActorType: z4.enum(["agent", "human"]).optional(),
   auctionType: AuctionType.nullable().optional(),
-  auctionStartPrice: z3.string().nullable().optional(),
-  auctionFloorPrice: z3.string().nullable().optional(),
-  currentAuctionPrice: z3.string().nullable().optional(),
-  auctionBidCount: z3.number().nullable().optional(),
-  auctionPriceReachesFloorAt: z3.string().nullable().optional(),
-  auctionPriceReachesMaxAt: z3.string().nullable().optional(),
-  currentLowestBid: z3.string().nullable().optional(),
-  hookContract: z3.string().nullable().optional(),
-  evaluator: z3.string().nullable().optional(),
-  evaluatorStake: z3.string().nullable().optional(),
+  auctionStartPrice: z4.string().nullable().optional(),
+  auctionFloorPrice: z4.string().nullable().optional(),
+  currentAuctionPrice: z4.string().nullable().optional(),
+  auctionBidCount: z4.number().nullable().optional(),
+  auctionPriceReachesFloorAt: z4.string().nullable().optional(),
+  auctionPriceReachesMaxAt: z4.string().nullable().optional(),
+  currentLowestBid: z4.string().nullable().optional(),
+  hookContract: z4.string().nullable().optional(),
+  evaluator: z4.string().nullable().optional(),
+  evaluatorStake: z4.string().nullable().optional(),
   // Genuinely absent when no evaluator is configured -- unlike `platformFeeBps`, null here means
   // "no evaluator fee", which is the same thing as zero, so a reader coalescing to 0 is right.
-  evaluatorFeeBps: z3.number().int().min(0).max(1e4).nullable().optional(),
-  evaluationWindow: z3.number().nullable().optional(),
-  appealWindow: z3.number().nullable().optional(),
-  disputeResolver: z3.string().nullable().optional(),
-  appealDeadline: z3.string().nullable().optional(),
-  evaluatorDeadline: z3.string().nullable().optional(),
-  verdictType: z3.enum(["APPROVE", "REJECT", "PARTIAL"]).nullable().optional(),
-  verdictScore: z3.number().nullable().optional(),
-  verdictConfidence: z3.number().nullable().optional(),
-  verdictEvidenceHash: z3.string().nullable().optional(),
-  submissionWindowOpen: z3.boolean(),
+  evaluatorFeeBps: z4.number().int().min(0).max(1e4).nullable().optional(),
+  evaluationWindow: z4.number().nullable().optional(),
+  appealWindow: z4.number().nullable().optional(),
+  disputeResolver: z4.string().nullable().optional(),
+  appealDeadline: z4.string().nullable().optional(),
+  evaluatorDeadline: z4.string().nullable().optional(),
+  verdictType: z4.enum(["APPROVE", "REJECT", "PARTIAL"]).nullable().optional(),
+  verdictScore: z4.number().nullable().optional(),
+  verdictConfidence: z4.number().nullable().optional(),
+  verdictEvidenceHash: z4.string().nullable().optional(),
+  submissionWindowOpen: z4.boolean(),
   phase: TaskPhase,
-  netReward: z3.string().nullable().optional(),
+  netReward: z4.string().nullable().optional(),
   pendingActions: PendingActionSchema.array().optional(),
-  selfAward: z3.boolean().nullable().optional(),
-  taskDropId: z3.string().nullable().optional(),
-  taskDrop: z3.object({
-    id: z3.string(),
-    name: z3.string()
+  selfAward: z4.boolean().nullable().optional(),
+  taskDropId: z4.string().nullable().optional(),
+  taskDrop: z4.object({
+    id: z4.string(),
+    name: z4.string()
   }).nullable().optional(),
-  hooks: z3.array(z3.string()).optional()
+  hooks: z4.array(z4.string()).optional()
 });
-var TaskListInputSchema = z3.object({
-  limit: z3.number().min(1).max(100).optional().default(20),
-  cursor: z3.string().optional(),
-  status: z3.union([TaskStatus, z3.literal("ALL")]).optional().default("ALL"),
+var TaskListInputSchema = z4.object({
+  limit: z4.number().min(1).max(100).optional().default(20),
+  cursor: z4.string().optional(),
+  status: z4.union([TaskStatus, z4.literal("ALL")]).optional().default("ALL"),
   phase: TaskPhase.optional(),
-  mode: z3.enum(["ALL", "bounty", "claim", "pitch", "benchmark", "auction"]).optional().default("ALL"),
+  mode: z4.enum(["ALL", "bounty", "claim", "pitch", "benchmark", "auction"]).optional().default("ALL"),
   auctionType: AuctionType.optional(),
-  requesterActorType: z3.enum(["agent", "human"]).optional(),
+  requesterActorType: z4.enum(["agent", "human"]).optional(),
   tags: csvArrayQueryParam(),
-  minReward: z3.string().optional(),
-  maxReward: z3.string().optional(),
-  deadlineHours: z3.number().int().positive().optional(),
-  requester: z3.string().optional(),
-  worker: z3.string().optional(),
-  taskDropId: z3.string().trim().min(1).optional(),
+  minReward: z4.string().optional(),
+  maxReward: z4.string().optional(),
+  deadlineHours: z4.number().int().positive().optional(),
+  requester: z4.string().optional(),
+  worker: z4.string().optional(),
+  taskDropId: z4.string().trim().min(1).optional(),
   // Free-text search (ADR-0099). Bounded at 200 characters so a single query cannot ask for
   // unbounded work; longer input is refused by Zod with a machine-readable reason (ADR-0058)
   // rather than silently truncated into a different query than the one the user typed.
-  q: z3.string().trim().min(1).max(200).optional(),
-  sort: z3.enum(["newest", "reward_desc", "reward_asc", "deadline_asc", "relevance"]).optional().default("newest")
+  q: z4.string().trim().min(1).max(200).optional(),
+  sort: z4.enum(["newest", "reward_desc", "reward_asc", "deadline_asc", "relevance"]).optional().default("newest")
 });
-var TaskListResponseSchema = z3.object({
-  tasks: z3.array(TaskResponseSchema),
-  nextCursor: z3.string().nullable(),
-  hasMore: z3.boolean()
+var TaskListResponseSchema = z4.object({
+  tasks: z4.array(TaskResponseSchema),
+  nextCursor: z4.string().nullable(),
+  hasMore: z4.boolean()
 });
-var TaskInboxInputSchema = z3.object({
-  address: z3.string()
+var TaskInboxInputSchema = z4.object({
+  address: z4.string()
 });
-var TaskInboxResponseSchema = z3.object({
-  asRequester: z3.array(TaskResponseSchema),
-  asWorker: z3.array(TaskResponseSchema),
+var TaskInboxResponseSchema = z4.object({
+  asRequester: z4.array(TaskResponseSchema),
+  asWorker: z4.array(TaskResponseSchema),
   // Phase 3 (ADR-0030): private tasks this address has been wallet-allowlisted onto,
   // surfaced here (self-authed only) as the in-app invite-discovery mechanism rather
   // than a separate notification-center feature.
-  invitedPrivateTasks: z3.array(TaskResponseSchema).optional().default([])
+  invitedPrivateTasks: z4.array(TaskResponseSchema).optional().default([])
 });
-var TaskActionIntent = z3.enum([
+var TaskActionIntent = z4.enum([
   "review_work",
   "select_worker",
   "submit_work",
@@ -477,25 +527,25 @@ var TaskActionIntent = z3.enum([
   "rate_workers",
   "select_auction_winner"
 ]);
-var TaskActionPriority = z3.enum(["urgent", "required", "follow_up"]);
-var TaskActionProgressSchema = z3.object({
-  completed: z3.number().int().nonnegative(),
-  total: z3.number().int().positive()
+var TaskActionPriority = z4.enum(["urgent", "required", "follow_up"]);
+var TaskActionProgressSchema = z4.object({
+  completed: z4.number().int().nonnegative(),
+  total: z4.number().int().positive()
 }).refine(({ completed, total }) => completed <= total, {
   message: "Completed progress cannot exceed the target total",
   path: ["completed"]
 });
-var TaskActionQueueItemSchema = z3.object({
-  id: z3.string(),
+var TaskActionQueueItemSchema = z4.object({
+  id: z4.string(),
   task: TaskResponseSchema,
   role: PendingActionSchema.shape.role,
   intent: TaskActionIntent,
   actions: PendingActionSchema.array().min(1),
   priority: TaskActionPriority,
-  dueAt: z3.string().nullable(),
+  dueAt: z4.string().nullable(),
   progress: TaskActionProgressSchema.nullable().optional()
 });
-var TaskActionWaitingReason = z3.enum([
+var TaskActionWaitingReason = z4.enum([
   "waiting_for_submissions",
   "waiting_for_worker",
   "waiting_for_review",
@@ -503,81 +553,81 @@ var TaskActionWaitingReason = z3.enum([
   "waiting_for_appeal_window",
   "waiting_for_settlement"
 ]);
-var TaskActionWaitingItemSchema = z3.object({
-  id: z3.string(),
+var TaskActionWaitingItemSchema = z4.object({
+  id: z4.string(),
   task: TaskResponseSchema,
   role: PendingActionSchema.shape.role,
   reason: TaskActionWaitingReason,
-  dueAt: z3.string().nullable()
+  dueAt: z4.string().nullable()
 });
-var TaskActionQueueResponseSchema = z3.object({
+var TaskActionQueueResponseSchema = z4.object({
   items: TaskActionQueueItemSchema.array(),
-  total: z3.number().int().nonnegative(),
-  urgentTotal: z3.number().int().nonnegative(),
+  total: z4.number().int().nonnegative(),
+  urgentTotal: z4.number().int().nonnegative(),
   waiting: TaskActionWaitingItemSchema.array()
 });
 var TaskDetailResponseSchema = TaskResponseSchema.extend({
   pendingActions: PendingActionSchema.array(),
   awards: TaskAwardSchema.array().optional(),
-  dreamsPerUsdc: z3.string().optional(),
+  dreamsPerUsdc: z4.string().optional(),
   // Optional as a set, not individually: the router emits `dreamsPerUsdc`, `bonusBps` and every
   // `estimated*` field together or not at all, depending on whether the task carries the DREAMS
   // hook. No client multiplies this by a split of its own -- the worker/requester estimates are
   // computed server-side -- so the absent case needs no fallback multiplier anywhere.
-  bonusBps: z3.number().int().min(0).max(1e4).optional(),
-  estimatedUsdBonusValue: z3.string().optional(),
-  estimatedWorkerUsdBonusValue: z3.string().optional(),
-  estimatedRequesterUsdBonusValue: z3.string().optional(),
-  estimatedWorkerDreamsBonus: z3.string().optional(),
-  estimatedRequesterDreamsBonus: z3.string().optional()
-});
-var CancelTaskInputSchema = z3.object({
-  taskId: z3.string()
-});
-var RejectSubmissionInputSchema = z3.object({
-  taskId: z3.string(),
-  worker: z3.string()
-});
-var AssignEvaluatorInputSchema = z3.object({
-  taskId: z3.string(),
-  evaluator: z3.string(),
+  bonusBps: z4.number().int().min(0).max(1e4).optional(),
+  estimatedUsdBonusValue: z4.string().optional(),
+  estimatedWorkerUsdBonusValue: z4.string().optional(),
+  estimatedRequesterUsdBonusValue: z4.string().optional(),
+  estimatedWorkerDreamsBonus: z4.string().optional(),
+  estimatedRequesterDreamsBonus: z4.string().optional()
+});
+var CancelTaskInputSchema = z4.object({
+  taskId: z4.string()
+});
+var RejectSubmissionInputSchema = z4.object({
+  taskId: z4.string(),
+  worker: z4.string()
+});
+var AssignEvaluatorInputSchema = z4.object({
+  taskId: z4.string(),
+  evaluator: z4.string(),
   // Integral: same field, same `uint16`, and the two request-side schemas must not disagree
   // about what a caller may send.
-  evaluatorFeeBps: z3.number().int().min(0).max(1e4).optional(),
-  evaluationWindowHours: z3.number().positive().optional(),
-  appealWindowHours: z3.number().positive().optional(),
-  disputeResolver: z3.string().optional()
+  evaluatorFeeBps: z4.number().int().min(0).max(1e4).optional(),
+  evaluationWindowHours: z4.number().positive().optional(),
+  appealWindowHours: z4.number().positive().optional(),
+  disputeResolver: z4.string().optional()
 });
-var RefundExpiredInputSchema = z3.object({
-  taskId: z3.string()
+var RefundExpiredInputSchema = z4.object({
+  taskId: z4.string()
 });
-var UpdateTaskInputSchema = z3.object({
-  taskId: z3.string(),
+var UpdateTaskInputSchema = z4.object({
+  taskId: z4.string(),
   reward: PositiveUsdcBaseUnitsSchema.optional(),
-  expiryTime: z3.number().int().positive().optional(),
-  bidDeadline: z3.number().int().positive().optional(),
-  pitchDeadline: z3.number().int().positive().optional(),
+  expiryTime: z4.number().int().positive().optional(),
+  bidDeadline: z4.number().int().positive().optional(),
+  pitchDeadline: z4.number().int().positive().optional(),
   auctionFloorPrice: UsdcBaseUnitsSchema.optional(),
   auctionStartPrice: UsdcBaseUnitsSchema.optional(),
-  description: z3.string().max(TASK_DESCRIPTION_MAX_LENGTH, "Description is too long").optional(),
-  tags: z3.array(z3.string()).max(10, "Maximum 10 tags allowed").optional(),
-  metricDescription: z3.string().max(500).optional()
+  description: z4.string().max(TASK_DESCRIPTION_MAX_LENGTH, "Description is too long").optional(),
+  tags: z4.array(z4.string()).max(10, "Maximum 10 tags allowed").optional(),
+  metricDescription: z4.string().max(500).optional()
 });
-var RequesterStatsSchema = z3.object({
-  completedCount: z3.number(),
-  selfAwardCount: z3.number(),
-  cancelledAfterSubmissionsCount: z3.number(),
-  expiredNoActionCount: z3.number(),
-  expiredAfterRejectionsCount: z3.number(),
-  totalTasksCreated: z3.number(),
-  totalSubmissionAttempts: z3.number(),
-  totalUniqueWorkers: z3.number()
+var RequesterStatsSchema = z4.object({
+  completedCount: z4.number(),
+  selfAwardCount: z4.number(),
+  cancelledAfterSubmissionsCount: z4.number(),
+  expiredNoActionCount: z4.number(),
+  expiredAfterRejectionsCount: z4.number(),
+  totalTasksCreated: z4.number(),
+  totalSubmissionAttempts: z4.number(),
+  totalUniqueWorkers: z4.number()
 });
 
 // ../../packages/shared/dist/schemas/submission.schemas.js
-import { z as z4 } from "zod";
-var ArtifactRole = z4.enum(["preview", "source", "final", "attachment"]);
-var ArtifactMediaKind = z4.enum([
+import { z as z5 } from "zod";
+var ArtifactRole = z5.enum(["preview", "source", "final", "attachment"]);
+var ArtifactMediaKind = z5.enum([
   "image",
   "video",
   "audio",
@@ -586,187 +636,187 @@ var ArtifactMediaKind = z4.enum([
   "archive",
   "unknown"
 ]);
-var ArtifactCreateSchema = z4.object({
-  fileName: z4.string().min(1, "File name is required").max(255, "File name is too long"),
-  mimeType: z4.string().min(1, "MIME type is required").max(120, "MIME type is too long"),
+var ArtifactCreateSchema = z5.object({
+  fileName: z5.string().min(1, "File name is required").max(255, "File name is too long"),
+  mimeType: z5.string().min(1, "MIME type is required").max(120, "MIME type is too long"),
   role: ArtifactRole.optional().default("attachment"),
-  file: z4.string().min(1, "File is required")
-});
-var ArtifactResponseSchema = z4.object({
-  id: z4.string(),
-  taskId: z4.string(),
-  submissionId: z4.string(),
-  workerAddress: z4.string(),
-  workerAgentId: z4.string().nullable(),
+  file: z5.string().min(1, "File is required")
+});
+var ArtifactResponseSchema = z5.object({
+  id: z5.string(),
+  taskId: z5.string(),
+  submissionId: z5.string(),
+  workerAddress: z5.string(),
+  workerAgentId: z5.string().nullable(),
   role: ArtifactRole,
-  fileName: z4.string(),
-  mimeType: z4.string(),
+  fileName: z5.string(),
+  mimeType: z5.string(),
   mediaKind: ArtifactMediaKind,
-  storageUri: z4.string(),
-  sizeBytes: z4.number(),
-  sha256Hash: z4.string(),
-  keccak256Hash: z4.string(),
-  displayOrder: z4.number(),
-  textPreview: z4.string().optional(),
-  previewUrl: z4.string().optional(),
-  previewExpiresAt: z4.string().optional()
-});
-var SubmissionCreateSchema = z4.object({
-  taskId: z4.string(),
-  workerAddress: z4.string(),
-  artifacts: z4.array(ArtifactCreateSchema).min(1).max(20),
-  signature: z4.string()
-});
-var SubmissionResponseSchema = z4.object({
-  id: z4.string(),
+  storageUri: z5.string(),
+  sizeBytes: z5.number(),
+  sha256Hash: z5.string(),
+  keccak256Hash: z5.string(),
+  displayOrder: z5.number(),
+  textPreview: z5.string().optional(),
+  previewUrl: z5.string().optional(),
+  previewExpiresAt: z5.string().optional()
+});
+var SubmissionCreateSchema = z5.object({
+  taskId: z5.string(),
+  workerAddress: z5.string(),
+  artifacts: z5.array(ArtifactCreateSchema).min(1).max(20),
+  signature: z5.string()
+});
+var SubmissionResponseSchema = z5.object({
+  id: z5.string(),
   // The submission's public name (ADR-0098), e.g. 'SUB-7K2QA9XF'. This is what the UI shows and
   // what search accepts; `id` stays the primary key and the idempotency key.
-  referenceCode: z4.string().nullable().optional(),
-  taskId: z4.string(),
-  workerAddress: z4.string(),
-  fileUrl: z4.string(),
-  signature: z4.string(),
-  submittedAt: z4.string(),
-  rejectedAt: z4.string().nullable().optional(),
-  workerAgentId: z4.string().nullable().optional(),
-  deliverableHash: z4.string().nullable().optional(),
-  submitTxHash: z4.string().nullable().optional(),
-  artifacts: z4.array(ArtifactResponseSchema).optional().default([]),
-  workerStats: z4.object({
-    completedTasks: z4.number(),
-    ratedTasks: z4.number(),
-    totalStars: z4.number(),
-    averageRating: z4.number()
+  referenceCode: z5.string().nullable().optional(),
+  taskId: z5.string(),
+  workerAddress: z5.string(),
+  fileUrl: z5.string(),
+  signature: z5.string(),
+  submittedAt: z5.string(),
+  rejectedAt: z5.string().nullable().optional(),
+  workerAgentId: z5.string().nullable().optional(),
+  deliverableHash: z5.string().nullable().optional(),
+  submitTxHash: z5.string().nullable().optional(),
+  artifacts: z5.array(ArtifactResponseSchema).optional().default([]),
+  workerStats: z5.object({
+    completedTasks: z5.number(),
+    ratedTasks: z5.number(),
+    totalStars: z5.number(),
+    averageRating: z5.number()
   }).nullable().optional()
 });
-var AgentWorkItemSchema = z4.object({
-  taskId: z4.string(),
-  taskTitle: z4.string(),
-  completedAt: z4.string(),
-  artifacts: z4.array(ArtifactResponseSchema)
+var AgentWorkItemSchema = z5.object({
+  taskId: z5.string(),
+  taskTitle: z5.string(),
+  completedAt: z5.string(),
+  artifacts: z5.array(ArtifactResponseSchema)
 });
-var AgentWorkResponseSchema = z4.array(AgentWorkItemSchema);
-var DownloadRequestSchema = z4.object({
-  acceptanceTxHash: z4.string(),
-  artifactId: z4.string().optional()
+var AgentWorkResponseSchema = z5.array(AgentWorkItemSchema);
+var DownloadRequestSchema = z5.object({
+  acceptanceTxHash: z5.string(),
+  artifactId: z5.string().optional()
 });
-var DownloadResponseSchema = z4.object({
-  fileUrl: z4.string(),
-  keyBundle: z4.string().nullable().optional(),
-  expiresAt: z4.string()
+var DownloadResponseSchema = z5.object({
+  fileUrl: z5.string(),
+  keyBundle: z5.string().nullable().optional(),
+  expiresAt: z5.string()
 });
 var MAX_ARTIFACT_BYTES = 500 * 1024 * 1024;
-var RequestUploadUrlInputSchema = z4.object({
-  taskId: z4.string(),
-  workerAddress: z4.string(),
-  signature: z4.string(),
-  fileName: z4.string().min(1, "File name is required").max(255, "File name is too long"),
-  mimeType: z4.string().min(1, "MIME type is required").max(120, "MIME type is too long"),
+var RequestUploadUrlInputSchema = z5.object({
+  taskId: z5.string(),
+  workerAddress: z5.string(),
+  signature: z5.string(),
+  fileName: z5.string().min(1, "File name is required").max(255, "File name is too long"),
+  mimeType: z5.string().min(1, "MIME type is required").max(120, "MIME type is too long"),
   role: ArtifactRole.optional().default("attachment"),
-  sizeBytes: z4.number().int().positive("Size must be positive").max(MAX_ARTIFACT_BYTES, "File must not exceed 500 MB")
+  sizeBytes: z5.number().int().positive("Size must be positive").max(MAX_ARTIFACT_BYTES, "File must not exceed 500 MB")
 });
-var RequestUploadUrlOutputSchema = z4.object({
-  uploadUrl: z4.string(),
-  artifactKey: z4.string()
+var RequestUploadUrlOutputSchema = z5.object({
+  uploadUrl: z5.string(),
+  artifactKey: z5.string()
 });
-var ArtifactKeyInputSchema = z4.object({
-  artifactKey: z4.string().min(1, "Artifact key is required"),
-  fileName: z4.string().min(1, "File name is required").max(255, "File name is too long"),
-  mimeType: z4.string().min(1, "MIME type is required").max(120, "MIME type is too long"),
+var ArtifactKeyInputSchema = z5.object({
+  artifactKey: z5.string().min(1, "Artifact key is required"),
+  fileName: z5.string().min(1, "File name is required").max(255, "File name is too long"),
+  mimeType: z5.string().min(1, "MIME type is required").max(120, "MIME type is too long"),
   role: ArtifactRole.optional().default("attachment"),
-  sizeBytes: z4.number().int().positive("Size must be positive").max(MAX_ARTIFACT_BYTES, "File must not exceed 500 MB"),
-  sha256Hash: z4.string().regex(/^[0-9a-f]{64}$/, "sha256Hash must be 64 lowercase hex chars"),
-  keccak256Hash: z4.string().regex(/^0x[0-9a-fA-F]{64}$/, "keccak256Hash must be 0x followed by 64 hex chars")
+  sizeBytes: z5.number().int().positive("Size must be positive").max(MAX_ARTIFACT_BYTES, "File must not exceed 500 MB"),
+  sha256Hash: z5.string().regex(/^[0-9a-f]{64}$/, "sha256Hash must be 64 lowercase hex chars"),
+  keccak256Hash: z5.string().regex(/^0x[0-9a-fA-F]{64}$/, "keccak256Hash must be 0x followed by 64 hex chars")
 });
-var SubmissionCreateFromKeysSchema = z4.object({
-  taskId: z4.string(),
-  workerAddress: z4.string(),
-  artifacts: z4.array(ArtifactKeyInputSchema).min(1).max(20),
-  signature: z4.string()
+var SubmissionCreateFromKeysSchema = z5.object({
+  taskId: z5.string(),
+  workerAddress: z5.string(),
+  artifacts: z5.array(ArtifactKeyInputSchema).min(1).max(20),
+  signature: z5.string()
 });
 
 // ../../packages/shared/dist/schemas/agent.schemas.js
-import { z as z5 } from "zod";
-var ActorType = z5.enum(["agent", "human"]);
-var RegistrationSource = z5.enum(["cli", "web"]);
-var AgentStatsSchema = z5.object({
-  address: z5.string(),
-  agentId: z5.string().nullable().optional(),
+import { z as z6 } from "zod";
+var ActorType = z6.enum(["agent", "human"]);
+var RegistrationSource = z6.enum(["cli", "web"]);
+var AgentStatsSchema = z6.object({
+  address: z6.string(),
+  agentId: z6.string().nullable().optional(),
   actorType: ActorType.optional(),
-  completedTasks: z5.number(),
-  ratedTasks: z5.number(),
-  totalStars: z5.number(),
-  averageRating: z5.number(),
-  totalEarnings: z5.string(),
-  skills: z5.array(z5.string()).optional(),
-  emailAddress: z5.string().nullable().optional(),
-  credibility: z5.number().int().min(0).max(1e3).optional(),
-  recentRatings: z5.array(z5.object({
-    taskId: z5.string(),
-    rating: z5.number(),
-    createdAt: z5.string(),
-    taskTitle: z5.string().nullable().optional(),
-    feedbackText: z5.string().nullable().optional()
+  completedTasks: z6.number(),
+  ratedTasks: z6.number(),
+  totalStars: z6.number(),
+  averageRating: z6.number(),
+  totalEarnings: z6.string(),
+  skills: z6.array(z6.string()).optional(),
+  emailAddress: z6.string().nullable().optional(),
+  credibility: z6.number().int().min(0).max(1e3).optional(),
+  recentRatings: z6.array(z6.object({
+    taskId: z6.string(),
+    rating: z6.number(),
+    createdAt: z6.string(),
+    taskTitle: z6.string().nullable().optional(),
+    feedbackText: z6.string().nullable().optional()
   })).optional()
 });
-var AgentRegistrationInputSchema = z5.object({
+var AgentRegistrationInputSchema = z6.object({
   source: RegistrationSource.optional().default("cli")
 });
-var LeaderboardInputSchema = z5.object({
+var LeaderboardInputSchema = z6.object({
   // RFC-0013 (Phase 1): the rate limiter on this endpoint bounds request count, not rows
   // returned per request -- an unbounded limit would let one request dump the whole agent
   // population regardless of the limiter, defeating the point of rate-limiting it at all.
-  limit: z5.number().int().min(1).max(100).optional().default(20),
-  offset: z5.number().optional().default(0),
-  sort: z5.enum(["reputation", "tasks"]).optional().default("reputation"),
-  skill: z5.string().optional(),
-  search: z5.string().optional(),
-  minRating: z5.number().min(0).max(5).optional(),
-  minTasks: z5.number().int().min(0).optional(),
+  limit: z6.number().int().min(1).max(100).optional().default(20),
+  offset: z6.number().optional().default(0),
+  sort: z6.enum(["reputation", "tasks"]).optional().default("reputation"),
+  skill: z6.string().optional(),
+  search: z6.string().optional(),
+  minRating: z6.number().min(0).max(5).optional(),
+  minTasks: z6.number().int().min(0).optional(),
   actorType: ActorType.optional()
 });
-var LeaderboardEntrySchema = z5.object({
-  rank: z5.number(),
-  address: z5.string(),
-  agentId: z5.string().nullable(),
+var LeaderboardEntrySchema = z6.object({
+  rank: z6.number(),
+  address: z6.string(),
+  agentId: z6.string().nullable(),
   actorType: ActorType.optional(),
-  completedTasks: z5.number(),
-  averageRating: z5.number(),
-  totalEarnings: z5.string(),
-  skills: z5.array(z5.string()),
-  emailAddress: z5.string().nullable().optional(),
-  credibility: z5.number().int().min(0).max(1e3).optional()
+  completedTasks: z6.number(),
+  averageRating: z6.number(),
+  totalEarnings: z6.string(),
+  skills: z6.array(z6.string()),
+  emailAddress: z6.string().nullable().optional(),
+  credibility: z6.number().int().min(0).max(1e3).optional()
 });
-var LeaderboardResponseSchema = z5.array(LeaderboardEntrySchema);
+var LeaderboardResponseSchema = z6.array(LeaderboardEntrySchema);
 
 // ../../packages/shared/dist/schemas/rating.schemas.js
-import { z as z6 } from "zod";
-var RatingInputSchema = z6.object({
-  taskId: z6.string(),
-  worker: z6.string(),
-  rating: z6.number().int().min(0).max(100),
-  feedbackText: z6.string().max(500).optional(),
-  raterAgentId: z6.number().int().nonnegative().optional()
-});
-var FeedbackSchema = z6.object({
-  id: z6.string(),
-  taskId: z6.string(),
-  workerAddress: z6.string(),
-  workerAgentId: z6.string().nullable(),
-  requesterAddress: z6.string(),
-  requesterAgentId: z6.string().nullable(),
-  rating: z6.number(),
-  feedbackText: z6.string().nullable(),
-  ratingTxHash: z6.string().nullable(),
-  createdAt: z6.string()
+import { z as z7 } from "zod";
+var RatingInputSchema = z7.object({
+  taskId: z7.string(),
+  worker: z7.string(),
+  rating: z7.number().int().min(0).max(100),
+  feedbackText: z7.string().max(500).optional(),
+  raterAgentId: z7.number().int().nonnegative().optional()
+});
+var FeedbackSchema = z7.object({
+  id: z7.string(),
+  taskId: z7.string(),
+  workerAddress: z7.string(),
+  workerAgentId: z7.string().nullable(),
+  requesterAddress: z7.string(),
+  requesterAgentId: z7.string().nullable(),
+  rating: z7.number(),
+  feedbackText: z7.string().nullable(),
+  ratingTxHash: z7.string().nullable(),
+  createdAt: z7.string()
 });
 
 // ../../packages/shared/dist/schemas/health.schemas.js
-import { z as z7 } from "zod";
-var HealthResponseSchema = z7.object({
-  status: z7.literal("ok"),
-  timestamp: z7.string(),
-  environment: z7.string(),
+import { z as z8 } from "zod";
+var HealthResponseSchema = z8.object({
+  status: z8.literal("ok"),
+  timestamp: z8.string(),
+  environment: z8.string(),
   /**
    * The commit this process was built from, when the deploy stamped one.
    *
@@ -780,7 +830,7 @@ var HealthResponseSchema = z7.object({
    * Absent rather than a placeholder when unstamped, so a local or unstamped process cannot
    * be mistaken for a verified one.
    */
-  commitSha: z7.string().optional(),
+  commitSha: z8.string().optional(),
   /**
    * The submission limits this process is actually enforcing, after any environment
    * override. Reported because a limit a caller cannot observe is a limit a test can only
@@ -788,9 +838,9 @@ var HealthResponseSchema = z7.object({
    * way to notice the backend was started with a different one, so it failed with a
    * confusing boundary error instead of saying the two disagreed.
    */
-  limits: z7.object({
-    freeSubmissionAllowance: z7.number().int().positive(),
-    hardSubmissionCeiling: z7.number().int().positive()
+  limits: z8.object({
+    freeSubmissionAllowance: z8.number().int().positive(),
+    hardSubmissionCeiling: z8.number().int().positive()
   }),
   /**
    * Relayed-intent facts a caller can poll for, in the same spirit as `limits`: a queryable
@@ -805,7 +855,7 @@ var HealthResponseSchema = z7.object({
    * Absent means "no answer here", and it covers a process whose sweep has not run yet as well
    * as one that does not sweep at all. It never means zero.
    */
-  intents: z7.object({
+  intents: z8.object({
     /**
      * When the count below was computed, not when it was served.
      *
@@ -814,67 +864,67 @@ var HealthResponseSchema = z7.object({
      * left behind by a worker that stopped running -- and the second is the more urgent of
      * the two, because a sweep that is not running is a queue nothing is draining.
      */
-    measuredAt: z7.string(),
+    measuredAt: z8.string(),
     /**
      * Intents that are neither completed nor failed and have not been touched for well past
      * normal settlement. A count only -- the endpoint is public.
      */
-    staleNonTerminal: z7.number().int().nonnegative()
+    staleNonTerminal: z8.number().int().nonnegative()
   }).optional()
 });
 
 // ../../packages/shared/dist/schemas/pitch.schemas.js
-import { z as z8 } from "zod";
-var PitchStatus = z8.enum(["pending", "selected", "rejected"]);
-var PitchCreateSchema = z8.object({
-  taskId: z8.string().min(1, "Task ID is required"),
-  workerAddress: z8.string().min(1, "Worker address is required"),
-  pitchText: z8.string().min(1, "Pitch text is required"),
-  estimatedDuration: z8.number().positive("Estimated duration must be positive").optional(),
-  signature: z8.string().min(1, "Signature is required")
-});
-var PitchResponseSchema = z8.object({
-  id: z8.string(),
-  taskId: z8.string(),
-  workerAddress: z8.string(),
-  pitchText: z8.string(),
-  estimatedDuration: z8.number().nullable(),
-  status: PitchStatus,
-  submittedAt: z8.string(),
-  workerAgentId: z8.string().nullable().optional(),
-  workerStats: z8.object({
-    completedTasks: z8.number(),
-    averageRating: z8.number().nullable()
-  }).optional()
-});
-var PitchSelectSchema = z8.object({
-  taskId: z8.string().min(1, "Task ID is required"),
-  pitchId: z8.string().min(1, "Pitch ID is required"),
-  workerAddress: z8.string().min(1, "Worker address is required"),
-  signature: z8.string().min(1, "Signature is required")
-});
-
-// ../../packages/shared/dist/schemas/claim.schemas.js
 import { z as z9 } from "zod";
-var ClaimStatus = z9.enum(["active", "submitted", "forfeited", "returned"]);
-var ClaimCreateSchema = z9.object({
+var PitchStatus = z9.enum(["pending", "selected", "rejected"]);
+var PitchCreateSchema = z9.object({
   taskId: z9.string().min(1, "Task ID is required"),
   workerAddress: z9.string().min(1, "Worker address is required"),
+  pitchText: z9.string().min(1, "Pitch text is required"),
+  estimatedDuration: z9.number().positive("Estimated duration must be positive").optional(),
   signature: z9.string().min(1, "Signature is required")
 });
-var ClaimResponseSchema = z9.object({
+var PitchResponseSchema = z9.object({
   id: z9.string(),
   taskId: z9.string(),
   workerAddress: z9.string(),
-  stakeAmount: z9.string(),
-  stakeTxHash: z9.string(),
-  claimedAt: z9.string(),
+  pitchText: z9.string(),
+  estimatedDuration: z9.number().nullable(),
+  status: PitchStatus,
+  submittedAt: z9.string(),
+  workerAgentId: z9.string().nullable().optional(),
+  workerStats: z9.object({
+    completedTasks: z9.number(),
+    averageRating: z9.number().nullable()
+  }).optional()
+});
+var PitchSelectSchema = z9.object({
+  taskId: z9.string().min(1, "Task ID is required"),
+  pitchId: z9.string().min(1, "Pitch ID is required"),
+  workerAddress: z9.string().min(1, "Worker address is required"),
+  signature: z9.string().min(1, "Signature is required")
+});
+
+// ../../packages/shared/dist/schemas/claim.schemas.js
+import { z as z10 } from "zod";
+var ClaimStatus = z10.enum(["active", "submitted", "forfeited", "returned"]);
+var ClaimCreateSchema = z10.object({
+  taskId: z10.string().min(1, "Task ID is required"),
+  workerAddress: z10.string().min(1, "Worker address is required"),
+  signature: z10.string().min(1, "Signature is required")
+});
+var ClaimResponseSchema = z10.object({
+  id: z10.string(),
+  taskId: z10.string(),
+  workerAddress: z10.string(),
+  stakeAmount: z10.string(),
+  stakeTxHash: z10.string(),
+  claimedAt: z10.string(),
   status: ClaimStatus
 });
 
 // ../../packages/shared/dist/schemas/proof.schemas.js
-import { z as z10 } from "zod";
-var ProofType = z10.enum([
+import { z as z11 } from "zod";
+var ProofType = z11.enum([
   "url",
   "screenshot",
   "api_data",
@@ -884,261 +934,261 @@ var ProofType = z10.enum([
   "tlsn",
   "zk"
 ]);
-var ProofStatus = z10.enum(["pending", "verified", "rejected"]);
-var ProofSubmitSchema = z10.object({
-  taskId: z10.string().min(1, "Task ID is required"),
-  workerAddress: z10.string().min(1, "Worker address is required"),
-  proofData: z10.string().min(1, "Proof data is required").max(1e4, "Proof data is too long"),
+var ProofStatus = z11.enum(["pending", "verified", "rejected"]);
+var ProofSubmitSchema = z11.object({
+  taskId: z11.string().min(1, "Task ID is required"),
+  workerAddress: z11.string().min(1, "Worker address is required"),
+  proofData: z11.string().min(1, "Proof data is required").max(1e4, "Proof data is too long"),
   proofType: ProofType,
-  metricValue: z10.string().max(200).optional(),
-  signature: z10.string().min(1, "Signature is required")
+  metricValue: z11.string().max(200).optional(),
+  signature: z11.string().min(1, "Signature is required")
 });
-var ProofResponseSchema = z10.object({
-  id: z10.string(),
-  taskId: z10.string(),
-  workerAddress: z10.string(),
-  proofData: z10.string(),
+var ProofResponseSchema = z11.object({
+  id: z11.string(),
+  taskId: z11.string(),
+  workerAddress: z11.string(),
+  proofData: z11.string(),
   proofType: ProofType,
-  metricValue: z10.string().nullable(),
+  metricValue: z11.string().nullable(),
   status: ProofStatus,
-  submissionId: z10.string().nullable(),
-  submittedAt: z10.string(),
-  workerAgentId: z10.string().nullable().optional()
+  submissionId: z11.string().nullable(),
+  submittedAt: z11.string(),
+  workerAgentId: z11.string().nullable().optional()
 });
 
 // ../../packages/shared/dist/schemas/bid.schemas.js
-import { z as z11 } from "zod";
-var BidCreateSchema = z11.object({
-  taskId: z11.string().min(1, "Task ID is required"),
+import { z as z12 } from "zod";
+var BidCreateSchema = z12.object({
+  taskId: z12.string().min(1, "Task ID is required"),
   price: PositiveUsdcBaseUnitsSchema
 });
-var AuctionAcceptSchema = z11.object({
-  taskId: z11.string().min(1, "Task ID is required"),
+var AuctionAcceptSchema = z12.object({
+  taskId: z12.string().min(1, "Task ID is required"),
   minPrice: UsdcBaseUnitsSchema.optional()
 });
-var BidResponseSchema = z11.object({
-  id: z11.string(),
-  taskId: z11.string(),
-  workerAddress: z11.string().nullable(),
-  price: z11.string().nullable(),
-  createdAt: z11.string(),
-  workerAgentId: z11.string().nullable().optional(),
-  isMyBid: z11.boolean().optional()
+var BidResponseSchema = z12.object({
+  id: z12.string(),
+  taskId: z12.string(),
+  workerAddress: z12.string().nullable(),
+  price: z12.string().nullable(),
+  createdAt: z12.string(),
+  workerAgentId: z12.string().nullable().optional(),
+  isMyBid: z12.boolean().optional()
 });
 
 // ../../packages/shared/dist/schemas/wallet.schemas.js
-import { z as z12 } from "zod";
-var SetWithdrawalAddressInputSchema = z12.object({
+import { z as z13 } from "zod";
+var SetWithdrawalAddressInputSchema = z13.object({
   walletAddress: EthAddressSchema,
   withdrawalAddress: EthAddressSchema,
-  signature: z12.string().min(1)
+  signature: z13.string().min(1)
 });
-var AccountRecoveryCodeSchema = z12.string().regex(/^\d{8}$/);
-var SetWithdrawalAddressOutputSchema = z12.object({
-  withdrawalAddress: z12.string(),
+var AccountRecoveryCodeSchema = z13.string().regex(/^\d{8}$/);
+var SetWithdrawalAddressOutputSchema = z13.object({
+  withdrawalAddress: z13.string(),
   // Returned exactly once, in this same response -- there is no other way to see it again.
   accountRecoveryCode: AccountRecoveryCodeSchema
 });
-var ChangeWithdrawalAddressInputSchema = z12.object({
+var ChangeWithdrawalAddressInputSchema = z13.object({
   address: EthAddressSchema,
   accountRecoveryCode: AccountRecoveryCodeSchema,
   newWithdrawalAddress: EthAddressSchema
 });
-var ChangeWithdrawalAddressOutputSchema = z12.object({
-  withdrawalAddress: z12.string(),
+var ChangeWithdrawalAddressOutputSchema = z13.object({
+  withdrawalAddress: z13.string(),
   // A fresh code, minted the same way, immediately: using a code invalidates it and
   // replaces it, so the operator always holds exactly one current, unused code.
   accountRecoveryCode: AccountRecoveryCodeSchema
 });
-var RevealBackfilledRecoveryCodeInputSchema = z12.object({
+var RevealBackfilledRecoveryCodeInputSchema = z13.object({
   address: EthAddressSchema,
-  signature: z12.string().min(1)
+  signature: z13.string().min(1)
 });
-var RevealBackfilledRecoveryCodeOutputSchema = z12.object({
+var RevealBackfilledRecoveryCodeOutputSchema = z13.object({
   accountRecoveryCode: AccountRecoveryCodeSchema
 });
-var UsdcDomainSchema = z12.object({
-  name: z12.string(),
-  version: z12.string(),
-  chainId: z12.number(),
-  verifyingContract: z12.string()
+var UsdcDomainSchema = z13.object({
+  name: z13.string(),
+  version: z13.string(),
+  chainId: z13.number(),
+  verifyingContract: z13.string()
 });
-var GetWithdrawalAddressOutputSchema = z12.object({
-  withdrawalAddress: z12.string().nullable(),
+var GetWithdrawalAddressOutputSchema = z13.object({
+  withdrawalAddress: z13.string().nullable(),
   usdcDomain: UsdcDomainSchema
 });
-var AuthorizationSchema = z12.object({
-  from: z12.string(),
-  to: z12.string(),
-  value: z12.string(),
-  validAfter: z12.string(),
-  validBefore: z12.string(),
-  nonce: z12.string()
+var AuthorizationSchema = z13.object({
+  from: z13.string(),
+  to: z13.string(),
+  value: z13.string(),
+  validAfter: z13.string(),
+  validBefore: z13.string(),
+  nonce: z13.string()
 });
-var WithdrawInputSchema = z12.object({
+var WithdrawInputSchema = z13.object({
   from: EthAddressSchema,
-  amountBaseUnits: z12.string().min(1),
+  amountBaseUnits: z13.string().min(1),
   authorization: AuthorizationSchema,
-  signature: z12.string().min(1)
+  signature: z13.string().min(1)
 });
-var WithdrawOutputSchema = z12.object({
-  txHash: z12.string(),
-  amountBaseUnits: z12.string(),
-  to: z12.string()
+var WithdrawOutputSchema = z13.object({
+  txHash: z13.string(),
+  amountBaseUnits: z13.string(),
+  to: z13.string()
 });
-var DreamsBalanceOutputSchema = z12.object({
-  claimableBaseUnits: z12.string()
+var DreamsBalanceOutputSchema = z13.object({
+  claimableBaseUnits: z13.string()
 });
-var WithdrawDreamsInputSchema = z12.object({
+var WithdrawDreamsInputSchema = z13.object({
   workerAddress: EthAddressSchema,
   destination: EthAddressSchema,
-  nonce: z12.string().min(1),
-  validBefore: z12.string().min(1),
-  signature: z12.string().min(1)
-});
-var WithdrawDreamsOutputSchema = z12.object({
-  txHash: z12.string(),
-  destination: z12.string(),
-  claimedBaseUnits: z12.string(),
-  dreamsPerUsdc: z12.string(),
-  usdEquivalent: z12.string()
-});
-var ExchangeRateOutputSchema = z12.object({
-  dreamsPerUsdc: z12.string(),
+  nonce: z13.string().min(1),
+  validBefore: z13.string().min(1),
+  signature: z13.string().min(1)
+});
+var WithdrawDreamsOutputSchema = z13.object({
+  txHash: z13.string(),
+  destination: z13.string(),
+  claimedBaseUnits: z13.string(),
+  dreamsPerUsdc: z13.string(),
+  usdEquivalent: z13.string()
+});
+var ExchangeRateOutputSchema = z13.object({
+  dreamsPerUsdc: z13.string(),
   // Both are read straight off `TaskTokenRewardHook`, which rejects either above 10000
   // (`InvalidBps`), and both are required here rather than optional: a client that had to
   // default the split would default it to the whole reward, and one that had to default the
   // bonus would report no bonus at all. Neither is a fact this endpoint may leave to the reader.
-  workerSplitBps: z12.number().int().min(0).max(1e4),
-  bonusBps: z12.number().int().min(0).max(1e4)
+  workerSplitBps: z13.number().int().min(0).max(1e4),
+  bonusBps: z13.number().int().min(0).max(1e4)
 });
 
 // ../../packages/shared/dist/schemas/xmtp.schemas.js
-import { z as z13 } from "zod";
-var XmtpPolicySchema = z13.enum(["allow", "deny", "quarantine"]);
-var XmtpPolicyModeSchema = z13.enum(["allowlist", "open"]);
-var AgentMessageEnvelopeSchema = z13.object({
-  schemaVersion: z13.literal(1),
-  type: z13.string().min(1),
-  requestId: z13.string().uuid(),
-  replyToRequestId: z13.string().uuid().nullable().optional(),
-  senderInboxId: z13.string().min(1),
+import { z as z14 } from "zod";
+var XmtpPolicySchema = z14.enum(["allow", "deny", "quarantine"]);
+var XmtpPolicyModeSchema = z14.enum(["allowlist", "open"]);
+var AgentMessageEnvelopeSchema = z14.object({
+  schemaVersion: z14.literal(1),
+  type: z14.string().min(1),
+  requestId: z14.string().uuid(),
+  replyToRequestId: z14.string().uuid().nullable().optional(),
+  senderInboxId: z14.string().min(1),
   senderAddress: EthAddressSchema,
-  sentAt: z13.string().datetime(),
-  deadlineMs: z13.number().int().positive().optional(),
-  payload: z13.record(z13.string(), z13.unknown())
-});
-var XmtpBootstrapInputSchema = z13.object({
-  deviceId: z13.string().min(1),
-  apiToken: z13.string().min(1),
-  inboxId: z13.string().min(1),
-  installationId: z13.string().min(1),
-  dbPath: z13.string().min(1).optional(),
-  clientVersion: z13.string().min(1).optional()
-});
-var XmtpBootstrapOutputSchema = z13.object({
-  inboxId: z13.string(),
-  installationId: z13.string(),
+  sentAt: z14.string().datetime(),
+  deadlineMs: z14.number().int().positive().optional(),
+  payload: z14.record(z14.string(), z14.unknown())
+});
+var XmtpBootstrapInputSchema = z14.object({
+  deviceId: z14.string().min(1),
+  apiToken: z14.string().min(1),
+  inboxId: z14.string().min(1),
+  installationId: z14.string().min(1),
+  dbPath: z14.string().min(1).optional(),
+  clientVersion: z14.string().min(1).optional()
+});
+var XmtpBootstrapOutputSchema = z14.object({
+  inboxId: z14.string(),
+  installationId: z14.string(),
   policyMode: XmtpPolicyModeSchema
 });
-var XmtpStatusInputSchema = z13.object({
-  deviceId: z13.string().min(1),
-  apiToken: z13.string().min(1).optional()
+var XmtpStatusInputSchema = z14.object({
+  deviceId: z14.string().min(1),
+  apiToken: z14.string().min(1).optional()
 });
-var XmtpStatusOutputSchema = z13.object({
-  inboxId: z13.string().nullable(),
-  enabled: z13.boolean(),
+var XmtpStatusOutputSchema = z14.object({
+  inboxId: z14.string().nullable(),
+  enabled: z14.boolean(),
   policyMode: XmtpPolicyModeSchema,
-  lastSeenAt: z13.string().datetime().nullable(),
-  activeInstallations: z13.array(z13.object({
-    installationId: z13.string(),
-    status: z13.string(),
-    lastSeenAt: z13.string().datetime()
+  lastSeenAt: z14.string().datetime().nullable(),
+  activeInstallations: z14.array(z14.object({
+    installationId: z14.string(),
+    status: z14.string(),
+    lastSeenAt: z14.string().datetime()
   }))
 });
-var XmtpHeartbeatInputSchema = z13.object({
-  deviceId: z13.string().min(1),
-  apiToken: z13.string().min(1),
-  installationId: z13.string().min(1)
+var XmtpHeartbeatInputSchema = z14.object({
+  deviceId: z14.string().min(1),
+  apiToken: z14.string().min(1),
+  installationId: z14.string().min(1)
 });
-var XmtpHeartbeatOutputSchema = z13.object({
-  ok: z13.literal(true)
+var XmtpHeartbeatOutputSchema = z14.object({
+  ok: z14.literal(true)
 });
-var XmtpPeerPolicyUpsertSchema = z13.object({
-  deviceId: z13.string().min(1),
-  apiToken: z13.string().min(1),
-  peerInboxId: z13.string().min(1),
+var XmtpPeerPolicyUpsertSchema = z14.object({
+  deviceId: z14.string().min(1),
+  apiToken: z14.string().min(1),
+  peerInboxId: z14.string().min(1),
   policy: XmtpPolicySchema,
-  reason: z13.string().min(1).optional()
+  reason: z14.string().min(1).optional()
 });
-var XmtpPeerPolicyListSchema = z13.object({
-  deviceId: z13.string().min(1),
-  apiToken: z13.string().min(1).optional()
+var XmtpPeerPolicyListSchema = z14.object({
+  deviceId: z14.string().min(1),
+  apiToken: z14.string().min(1).optional()
 });
-var XmtpPeerPolicyUpsertOutputSchema = z13.object({
-  ok: z13.literal(true)
+var XmtpPeerPolicyUpsertOutputSchema = z14.object({
+  ok: z14.literal(true)
 });
-var XmtpPeerPolicyListOutputSchema = z13.object({
-  policies: z13.array(z13.object({
-    peerInboxId: z13.string(),
+var XmtpPeerPolicyListOutputSchema = z14.object({
+  policies: z14.array(z14.object({
+    peerInboxId: z14.string(),
     policy: XmtpPolicySchema,
-    reason: z13.string().nullable(),
-    updatedAt: z13.string().datetime()
+    reason: z14.string().nullable(),
+    updatedAt: z14.string().datetime()
   }))
 });
-var XmtpResolvePeerInputSchema = z13.object({
+var XmtpResolvePeerInputSchema = z14.object({
   address: EthAddressSchema.optional(),
-  agentId: z13.string().min(1).optional()
+  agentId: z14.string().min(1).optional()
 }).refine((value) => Boolean(value.address || value.agentId), {
   message: "Either address or agentId is required"
 });
-var XmtpResolvePeerOutputSchema = z13.object({
+var XmtpResolvePeerOutputSchema = z14.object({
   address: EthAddressSchema.nullable(),
-  inboxId: z13.string().nullable()
+  inboxId: z14.string().nullable()
 });
 
 // ../../packages/shared/dist/schemas/email.schemas.js
-import { z as z14 } from "zod";
-var EmailSchema = z14.object({
-  id: z14.string(),
-  fromAddress: z14.string(),
-  toAddress: z14.string(),
-  subject: z14.string().nullable(),
-  bodyText: z14.string().nullable(),
-  bodyHtml: z14.string().nullable(),
-  isRead: z14.boolean(),
-  receivedAt: z14.string()
-});
-var SendEmailInputSchema = z14.object({
-  to: z14.string().email(),
-  subject: z14.string().min(1),
-  bodyText: z14.string().min(1)
-});
-var EmailInboundHeadersSchema = z14.object({
-  "x-webhook-secret": z14.string(),
-  "x-email-from": z14.string(),
-  "x-email-to": z14.string().email()
-});
-var BroadcastInputSchema = z14.object({
-  subject: z14.string().min(1).max(200),
-  body: z14.string().min(1).max(5e4),
-  filters: z14.object({
-    skills: z14.array(z14.string()).max(20).optional(),
-    minTasks: z14.number().int().min(0).optional(),
-    actorType: z14.enum(["agent", "human", "all"]).optional()
+import { z as z15 } from "zod";
+var EmailSchema = z15.object({
+  id: z15.string(),
+  fromAddress: z15.string(),
+  toAddress: z15.string(),
+  subject: z15.string().nullable(),
+  bodyText: z15.string().nullable(),
+  bodyHtml: z15.string().nullable(),
+  isRead: z15.boolean(),
+  receivedAt: z15.string()
+});
+var SendEmailInputSchema = z15.object({
+  to: z15.string().email(),
+  subject: z15.string().min(1),
+  bodyText: z15.string().min(1)
+});
+var EmailInboundHeadersSchema = z15.object({
+  "x-webhook-secret": z15.string(),
+  "x-email-from": z15.string(),
+  "x-email-to": z15.string().email()
+});
+var BroadcastInputSchema = z15.object({
+  subject: z15.string().min(1).max(200),
+  body: z15.string().min(1).max(5e4),
+  filters: z15.object({
+    skills: z15.array(z15.string()).max(20).optional(),
+    minTasks: z15.number().int().min(0).optional(),
+    actorType: z15.enum(["agent", "human", "all"]).optional()
   }).optional()
 });
-var BroadcastResultSchema = z14.object({
-  sent: z14.number(),
-  failed: z14.number(),
-  total: z14.number()
+var BroadcastResultSchema = z15.object({
+  sent: z15.number(),
+  failed: z15.number(),
+  total: z15.number()
 });
 
 // ../../packages/shared/dist/schemas/stats.schemas.js
-import { z as z15 } from "zod";
-var TimeRangeEnum = z15.enum(["7d", "30d", "90d", "all"]);
-var BucketEnum = z15.enum(["day", "week"]);
-var ActivityTypeEnum = z15.enum([
+import { z as z16 } from "zod";
+var TimeRangeEnum = z16.enum(["7d", "30d", "90d", "all"]);
+var BucketEnum = z16.enum(["day", "week"]);
+var ActivityTypeEnum = z16.enum([
   "task_created",
   "task_submitted",
   "task_claimed",
@@ -1146,208 +1196,208 @@ var ActivityTypeEnum = z15.enum([
   "bid_placed",
   "task_rated"
 ]);
-var ActorTypeEnum = z15.enum(["human", "agent"]);
-var PlatformTimeSeriesInputSchema = z15.object({
+var ActorTypeEnum = z16.enum(["human", "agent"]);
+var PlatformTimeSeriesInputSchema = z16.object({
   range: TimeRangeEnum.optional().default("30d"),
   bucket: BucketEnum.optional().default("day")
 });
-var PlatformTimeSeriesPointSchema = z15.object({
-  bucket: z15.string(),
-  tasksCreated: z15.number(),
-  rewardVolume: z15.string(),
-  completedTasks: z15.number(),
-  newAgents: z15.number(),
-  activeAgents: z15.number()
-});
-var PlatformTimeSeriesResponseSchema = z15.array(PlatformTimeSeriesPointSchema);
-var AgentTimeSeriesInputSchema = z15.object({
-  address: z15.string().optional(),
-  agentId: z15.string().optional(),
+var PlatformTimeSeriesPointSchema = z16.object({
+  bucket: z16.string(),
+  tasksCreated: z16.number(),
+  rewardVolume: z16.string(),
+  completedTasks: z16.number(),
+  newAgents: z16.number(),
+  activeAgents: z16.number()
+});
+var PlatformTimeSeriesResponseSchema = z16.array(PlatformTimeSeriesPointSchema);
+var AgentTimeSeriesInputSchema = z16.object({
+  address: z16.string().optional(),
+  agentId: z16.string().optional(),
   range: TimeRangeEnum.optional().default("90d"),
   bucket: BucketEnum.optional().default("week")
 }).refine((v) => Boolean(v.address) || Boolean(v.agentId), {
   message: "Provide address or agentId"
 });
-var AgentTimeSeriesPointSchema = z15.object({
-  bucket: z15.string(),
-  earnings: z15.string(),
-  cumulativeEarnings: z15.string(),
-  tasksCompleted: z15.number(),
-  avgRating: z15.number().nullable(),
-  ratingsCount: z15.number(),
-  activityCount: z15.number()
-});
-var AgentTimeSeriesResponseSchema = z15.array(AgentTimeSeriesPointSchema);
-var BreakdownsInputSchema = z15.object({});
-var BreakdownsResponseSchema = z15.object({
-  status: z15.array(z15.object({ status: z15.string(), count: z15.number() })),
-  mode: z15.array(z15.object({ mode: z15.string(), count: z15.number() })),
-  actorType: z15.array(z15.object({ actorType: ActorTypeEnum, count: z15.number() }))
-});
-var ActivityFeedInputSchema = z15.object({
-  limit: z15.number().int().min(1).max(50).optional().default(20),
-  cursor: z15.string().optional(),
-  types: z15.array(ActivityTypeEnum).optional()
-});
-var ActivityFeedItemSchema = z15.object({
+var AgentTimeSeriesPointSchema = z16.object({
+  bucket: z16.string(),
+  earnings: z16.string(),
+  cumulativeEarnings: z16.string(),
+  tasksCompleted: z16.number(),
+  avgRating: z16.number().nullable(),
+  ratingsCount: z16.number(),
+  activityCount: z16.number()
+});
+var AgentTimeSeriesResponseSchema = z16.array(AgentTimeSeriesPointSchema);
+var BreakdownsInputSchema = z16.object({});
+var BreakdownsResponseSchema = z16.object({
+  status: z16.array(z16.object({ status: z16.string(), count: z16.number() })),
+  mode: z16.array(z16.object({ mode: z16.string(), count: z16.number() })),
+  actorType: z16.array(z16.object({ actorType: ActorTypeEnum, count: z16.number() }))
+});
+var ActivityFeedInputSchema = z16.object({
+  limit: z16.number().int().min(1).max(50).optional().default(20),
+  cursor: z16.string().optional(),
+  types: z16.array(ActivityTypeEnum).optional()
+});
+var ActivityFeedItemSchema = z16.object({
   type: ActivityTypeEnum,
-  timestamp: z15.string(),
-  taskId: z15.string(),
-  taskTitle: z15.string().nullable(),
-  actor: z15.string(),
+  timestamp: z16.string(),
+  taskId: z16.string(),
+  taskTitle: z16.string().nullable(),
+  actor: z16.string(),
   actorType: ActorTypeEnum,
-  amount: z15.string().nullable(),
-  rating: z15.number().nullable()
+  amount: z16.string().nullable(),
+  rating: z16.number().nullable()
 });
-var ActivityFeedResponseSchema = z15.object({
-  items: z15.array(ActivityFeedItemSchema),
-  nextCursor: z15.string().nullable()
+var ActivityFeedResponseSchema = z16.object({
+  items: z16.array(ActivityFeedItemSchema),
+  nextCursor: z16.string().nullable()
 });
-var HeatmapDimensionEnum = z15.enum(["mode", "hourOfWeek"]);
-var ActivityHeatmapInputSchema = z15.object({
+var HeatmapDimensionEnum = z16.enum(["mode", "hourOfWeek"]);
+var ActivityHeatmapInputSchema = z16.object({
   range: TimeRangeEnum.optional().default("30d"),
   dimension: HeatmapDimensionEnum.optional().default("mode")
 });
-var ActivityHeatmapCellSchema = z15.object({
-  row: z15.string(),
-  col: z15.string(),
-  count: z15.number(),
-  volume: z15.string()
+var ActivityHeatmapCellSchema = z16.object({
+  row: z16.string(),
+  col: z16.string(),
+  count: z16.number(),
+  volume: z16.string()
 });
-var ActivityHeatmapResponseSchema = z15.object({
-  rowKeys: z15.array(z15.string()),
-  colKeys: z15.array(z15.string()),
-  cells: z15.array(ActivityHeatmapCellSchema),
-  maxCount: z15.number()
+var ActivityHeatmapResponseSchema = z16.object({
+  rowKeys: z16.array(z16.string()),
+  colKeys: z16.array(z16.string()),
+  cells: z16.array(ActivityHeatmapCellSchema),
+  maxCount: z16.number()
 });
 
 // ../../packages/shared/dist/schemas/evaluation.schemas.js
-import { z as z16 } from "zod";
-var EvaluationAwardInputSchema = z16.object({
-  worker: z16.string(),
+import { z as z17 } from "zod";
+var EvaluationAwardInputSchema = z17.object({
+  worker: z17.string(),
   amount: PositiveUsdcBaseUnitsSchema,
-  rank: z16.number().int().min(1)
+  rank: z17.number().int().min(1)
 });
-var EvaluateInputSchema = z16.object({
-  taskId: z16.string(),
-  verdict: z16.enum(["approve", "reject", "partial"]),
-  score: z16.number().int().min(0).max(1e3).optional().default(1e3),
-  confidence: z16.number().int().min(0).max(1e3).optional().default(1e3),
-  evidenceHash: z16.string().regex(/^0x[0-9a-fA-F]{64}$/).optional().default("0x0000000000000000000000000000000000000000000000000000000000000000"),
-  awards: z16.array(EvaluationAwardInputSchema).optional().default([])
-});
-var AppealInputSchema = z16.object({ taskId: z16.string() });
-var FinalizeVerdictInputSchema = z16.object({ taskId: z16.string() });
-var ResolveDisputeInputSchema = z16.object({
-  taskId: z16.string(),
-  verdict: z16.enum(["approve", "partial"]),
-  awards: z16.array(EvaluationAwardInputSchema).min(1)
+var EvaluateInputSchema = z17.object({
+  taskId: z17.string(),
+  verdict: z17.enum(["approve", "reject", "partial"]),
+  score: z17.number().int().min(0).max(1e3).optional().default(1e3),
+  confidence: z17.number().int().min(0).max(1e3).optional().default(1e3),
+  evidenceHash: z17.string().regex(/^0x[0-9a-fA-F]{64}$/).optional().default("0x0000000000000000000000000000000000000000000000000000000000000000"),
+  awards: z17.array(EvaluationAwardInputSchema).optional().default([])
+});
+var AppealInputSchema = z17.object({ taskId: z17.string() });
+var FinalizeVerdictInputSchema = z17.object({ taskId: z17.string() });
+var ResolveDisputeInputSchema = z17.object({
+  taskId: z17.string(),
+  verdict: z17.enum(["approve", "partial"]),
+  awards: z17.array(EvaluationAwardInputSchema).min(1)
 });
-var EvaluatorTimeoutInputSchema = z16.object({ taskId: z16.string() });
+var EvaluatorTimeoutInputSchema = z17.object({ taskId: z17.string() });
 
 // ../../packages/shared/dist/schemas/legal.schemas.js
-import { z as z17 } from "zod";
-var LegalDocumentTypeSchema = z17.enum([
+import { z as z18 } from "zod";
+var LegalDocumentTypeSchema = z18.enum([
   "terms_of_service",
   "privacy_policy",
   "risk_disclosure",
   "acceptable_use_policy"
 ]);
-var LegalDocumentSlugSchema = z17.enum(["terms", "privacy", "risks", "acceptable-use"]);
-var LegalSha256DigestSchema = z17.string().regex(/^sha256:[a-f0-9]{64}$/);
-var LegalBundleDocumentSchema = z17.object({
+var LegalDocumentSlugSchema = z18.enum(["terms", "privacy", "risks", "acceptable-use"]);
+var LegalSha256DigestSchema = z18.string().regex(/^sha256:[a-f0-9]{64}$/);
+var LegalBundleDocumentSchema = z18.object({
   contentHash: LegalSha256DigestSchema,
   slug: LegalDocumentSlugSchema,
-  summary: z17.string(),
-  title: z17.string(),
+  summary: z18.string(),
+  title: z18.string(),
   type: LegalDocumentTypeSchema,
-  url: z17.string().url(),
-  version: z17.string()
+  url: z18.string().url(),
+  version: z18.string()
 });
-var LegalBundleSchema = z17.object({
-  acceptanceAvailable: z17.boolean(),
-  acceptanceStatement: z17.string(),
+var LegalBundleSchema = z18.object({
+  acceptanceAvailable: z18.boolean(),
+  acceptanceStatement: z18.string(),
   bundleDigest: LegalSha256DigestSchema,
-  documents: z17.array(LegalBundleDocumentSchema),
-  effectiveAt: z17.string().nullable(),
-  enforcementEnabled: z17.boolean(),
-  privyAppId: z17.string().nullable(),
-  publishedAt: z17.string(),
-  status: z17.enum(["draft", "approved"]),
-  version: z17.string()
-});
-var LegalSubjectTypeSchema = z17.enum(["privy_user", "wallet"]);
-var LegalStatusResponseSchema = z17.object({
-  accepted: z17.boolean(),
+  documents: z18.array(LegalBundleDocumentSchema),
+  effectiveAt: z18.string().nullable(),
+  enforcementEnabled: z18.boolean(),
+  privyAppId: z18.string().nullable(),
+  publishedAt: z18.string(),
+  status: z18.enum(["draft", "approved"]),
+  version: z18.string()
+});
+var LegalSubjectTypeSchema = z18.enum(["privy_user", "wallet"]);
+var LegalStatusResponseSchema = z18.object({
+  accepted: z18.boolean(),
   bundle: LegalBundleSchema,
-  receipt: z17.string().optional(),
+  receipt: z18.string().optional(),
   subjectType: LegalSubjectTypeSchema.optional()
 });
 var LegalWalletAddressSchema = EthAddressSchema;
-var LegalAffirmationsSchema = z17.object({
-  acknowledgedRisk: z17.literal(true),
-  agreedToAcceptableUse: z17.literal(true),
-  agreedToTerms: z17.literal(true),
-  receivedPrivacyNotice: z17.literal(true)
+var LegalAffirmationsSchema = z18.object({
+  acknowledgedRisk: z18.literal(true),
+  agreedToAcceptableUse: z18.literal(true),
+  agreedToTerms: z18.literal(true),
+  receivedPrivacyNotice: z18.literal(true)
 });
-var LegalChallengeInputSchema = z17.object({
+var LegalChallengeInputSchema = z18.object({
   walletAddress: LegalWalletAddressSchema
 });
-var LegalChallengeResponseSchema = z17.object({
+var LegalChallengeResponseSchema = z18.object({
   bundle: LegalBundleSchema,
-  expiresAt: z17.string(),
-  issuedAt: z17.string(),
-  message: z17.string(),
-  nonce: z17.string().uuid(),
+  expiresAt: z18.string(),
+  issuedAt: z18.string(),
+  message: z18.string(),
+  nonce: z18.string().uuid(),
   walletAddress: LegalWalletAddressSchema
 });
-var LegalAcceptanceBundleSchema = z17.object({
+var LegalAcceptanceBundleSchema = z18.object({
   bundleDigest: LegalSha256DigestSchema,
-  bundleVersion: z17.string().max(128)
+  bundleVersion: z18.string().max(128)
 });
 var LegalWalletAcceptanceInputSchema = LegalAffirmationsSchema.merge(LegalAcceptanceBundleSchema).extend({
-  nonce: z17.string().uuid(),
-  signature: z17.string().regex(/^0x[a-fA-F0-9]{128}(?:[a-fA-F0-9]{2})?$/),
+  nonce: z18.string().uuid(),
+  signature: z18.string().regex(/^0x[a-fA-F0-9]{128}(?:[a-fA-F0-9]{2})?$/),
   walletAddress: LegalWalletAddressSchema
 });
 var LegalWebAcceptanceInputSchema = LegalAffirmationsSchema.merge(LegalAcceptanceBundleSchema);
-var LegalAcceptanceResponseSchema = z17.object({
-  acceptedAt: z17.string(),
+var LegalAcceptanceResponseSchema = z18.object({
+  acceptedAt: z18.string(),
   bundleDigest: LegalSha256DigestSchema,
-  bundleVersion: z17.string(),
-  receipt: z17.string()
+  bundleVersion: z18.string(),
+  receipt: z18.string()
 });
 
 // ../../packages/shared/dist/schemas/task-access.schemas.js
-import { z as z18 } from "zod";
-var VerifyTaskAccessPasswordInputSchema = z18.object({
-  taskId: z18.string(),
-  password: z18.string().min(1)
+import { z as z19 } from "zod";
+var VerifyTaskAccessPasswordInputSchema = z19.object({
+  taskId: z19.string(),
+  password: z19.string().min(1)
 });
-var VerifyTaskAccessPasswordResponseSchema = z18.object({
-  grant: z18.string(),
-  expiresAt: z18.string()
+var VerifyTaskAccessPasswordResponseSchema = z19.object({
+  grant: z19.string(),
+  expiresAt: z19.string()
 });
-var AddAllowedViewerInputSchema = z18.object({
-  taskId: z18.string(),
-  viewerAddress: z18.string()
+var AddAllowedViewerInputSchema = z19.object({
+  taskId: z19.string(),
+  viewerAddress: z19.string()
 });
-var RemoveAllowedViewerInputSchema = z18.object({
-  taskId: z18.string(),
-  viewerAddress: z18.string()
+var RemoveAllowedViewerInputSchema = z19.object({
+  taskId: z19.string(),
+  viewerAddress: z19.string()
 });
-var ListAllowedViewersInputSchema = z18.object({
-  taskId: z18.string()
+var ListAllowedViewersInputSchema = z19.object({
+  taskId: z19.string()
 });
-var AllowedViewerResponseSchema = z18.object({
-  viewerAddress: z18.string(),
-  addedBy: z18.string(),
-  createdAt: z18.string()
+var AllowedViewerResponseSchema = z19.object({
+  viewerAddress: z19.string(),
+  addedBy: z19.string(),
+  createdAt: z19.string()
 });
-var ListAllowedViewersResponseSchema = z18.array(AllowedViewerResponseSchema);
+var ListAllowedViewersResponseSchema = z19.array(AllowedViewerResponseSchema);
 
 // ../../packages/shared/dist/schemas/api-error.schemas.js
-import { z as z19 } from "zod";
+import { z as z20 } from "zod";
 var API_ERROR_REASONS = [
   /**
    * No terminal outcome has been established. The write is owned by the settlement path and
@@ -1421,37 +1471,38 @@ var API_ERROR_REASONS = [
    */
   "unclassified"
 ];
-var ApiErrorReasonSchema = z19.enum(API_ERROR_REASONS);
-var ApiErrorIntentStatusSchema = z19.enum([
+var ApiErrorReasonSchema = z20.enum(API_ERROR_REASONS);
+var ApiErrorIntentStatusSchema = z20.enum([
   "reserved",
   "recorded",
   "broadcast",
   "completed",
-  "failed"
+  "failed",
+  "held"
 ]);
 var REASONS_WITHOUT_REQUIRED_INTENT_STATUS = API_ERROR_REASONS.filter((reason) => reason !== "idempotency_key_reused");
 var ENVELOPE_FIELDS = {
   /** The durable handle to the write, where one was recorded. Key on this, not on `txHash`. */
-  intentId: z19.string().optional(),
+  intentId: z20.string().optional(),
   /** The operation the intent stands for, e.g. `tasks.create`. */
-  operation: z19.string().optional(),
+  operation: z20.string().optional(),
   /** The caller's own key for the operation, echoed so a dropped response is still traceable. */
-  idempotencyKey: z19.string().optional(),
+  idempotencyKey: z20.string().optional(),
   /**
    * Known once something has been broadcast, and explicitly not the handle: the reconciler may
    * land a replacement at the same nonce, which is a different hash for the same intent.
    */
-  txHash: z19.string().optional()
+  txHash: z20.string().optional()
 };
-var ApiErrorEnvelopeSchema = z19.discriminatedUnion("reason", [
-  z19.object({
-    reason: z19.literal("idempotency_key_reused"),
+var ApiErrorEnvelopeSchema = z20.discriminatedUnion("reason", [
+  z20.object({
+    reason: z20.literal("idempotency_key_reused"),
     /** Required here: the reason means an intent under this key exists, so it has a status. */
     intentStatus: ApiErrorIntentStatusSchema,
     ...ENVELOPE_FIELDS
   }),
-  z19.object({
-    reason: z19.enum(REASONS_WITHOUT_REQUIRED_INTENT_STATUS),
+  z20.object({
+    reason: z20.enum(REASONS_WITHOUT_REQUIRED_INTENT_STATUS),
     /** The intent's status at the moment this answer was produced, where there is an intent. */
     intentStatus: ApiErrorIntentStatusSchema.optional(),
     ...ENVELOPE_FIELDS
@@ -1483,35 +1534,40 @@ function apiErrorEnvelopeOf(value) {
 }
 
 // ../../packages/shared/dist/schemas/intent.schemas.js
-import { z as z20 } from "zod";
-var IntentStatusInputSchema = z20.object({
-  intentId: z20.string().min(1).optional(),
-  idempotencyKey: z20.string().min(1).optional()
+import { z as z21 } from "zod";
+var IntentStatusInputSchema = z21.object({
+  intentId: z21.string().min(1).optional(),
+  idempotencyKey: z21.string().min(1).optional()
 }).refine((value) => Boolean(value.intentId) !== Boolean(value.idempotencyKey), {
   message: "Provide exactly one of intentId or idempotencyKey"
 });
-var IntentRefundStateSchema = z20.object({
-  status: z20.enum(["pending", "refunding", "refunded", "failed"]),
-  txHash: z20.string().nullable()
+var IntentRefundStateSchema = z21.object({
+  status: z21.enum(["pending", "refunding", "refunded", "failed"]),
+  txHash: z21.string().nullable()
 });
-var IntentStatusResponseSchema = z20.object({
-  intentId: z20.string(),
-  idempotencyKey: z20.string(),
+var IntentStatusResponseSchema = z21.object({
+  intentId: z21.string(),
+  idempotencyKey: z21.string(),
   /** The operation kind, e.g. `tasks.create`. */
-  operation: z20.string(),
+  operation: z21.string(),
   /**
    * `reserved` is the pre-payment state (ADR-0067): the key is claimed and the caller has been
    * challenged, but no payment has landed and nothing has been sent to the chain. It is
    * non-terminal, it is never broadcastable, and it expires if it is never filled.
+   *
+   * `held` is the one case an expired reservation is neither released nor failed: the token
+   * contract says its authorization was consumed, so money moved, but nothing ever attached
+   * a payment reference to this row. It stays on record for manual reconciliation rather than
+   * being deleted or reported as failed.
    */
-  status: z20.enum(["reserved", "recorded", "broadcast", "completed", "failed"]),
+  status: z21.enum(["reserved", "recorded", "broadcast", "completed", "failed", "held"]),
   /**
    * Known once something has been broadcast, and explicitly not the handle: the reconciler
    * may land a replacement at the same nonce, which is a different hash for the same intent.
    */
-  txHash: z20.string().nullable(),
+  txHash: z21.string().nullable(),
   /** Why it failed, where it did. Null on every non-terminal status. */
-  terminalReason: z20.string().nullable(),
+  terminalReason: z21.string().nullable(),
   /**
    * The task a completed `tasks.create` produced.
    *
@@ -1521,7 +1577,7 @@ var IntentStatusResponseSchema = z20.object({
    * would be a guess of the kind that made concurrent creates overwrite each other. Null
    * until the intent completes, and null for every other operation.
    */
-  taskId: z20.string().nullable(),
+  taskId: z21.string().nullable(),
   /**
    * Only present where the intent carried a payment and that payment has been written off.
    * Null means no refund has been decided -- which is not the same as "no refund is coming"
@@ -1533,7 +1589,7 @@ var IntentStatusResponseSchema = z20.object({
     for (const field of ["txHash", "terminalReason", "taskId"]) {
       if (value[field] !== null) {
         ctx.addIssue({
-          code: z20.ZodIssueCode.custom,
+          code: z21.ZodIssueCode.custom,
           path: [field],
           message: `A reserved intent has not been sent to the chain, so ${field} must be null`
         });
@@ -1543,7 +1599,7 @@ var IntentStatusResponseSchema = z20.object({
   }
   if (value.terminalReason !== null && value.status !== "failed") {
     ctx.addIssue({
-      code: z20.ZodIssueCode.custom,
+      code: z21.ZodIssueCode.custom,
       path: ["terminalReason"],
       message: "Only a failed intent has a terminal reason"
     });
@@ -1552,7 +1608,7 @@ var IntentStatusResponseSchema = z20.object({
     return;
   if (value.status !== "completed") {
     ctx.addIssue({
-      code: z20.ZodIssueCode.custom,
+      code: z21.ZodIssueCode.custom,
       path: ["taskId"],
       message: "taskId is only known once the intent has completed"
     });
@@ -1560,7 +1616,7 @@ var IntentStatusResponseSchema = z20.object({
   }
   if (value.operation !== "tasks.create") {
     ctx.addIssue({
-      code: z20.ZodIssueCode.custom,
+      code: z21.ZodIssueCode.custom,
       path: ["taskId"],
       message: "Only a tasks.create intent produces a taskId"
     });
@@ -1568,80 +1624,80 @@ var IntentStatusResponseSchema = z20.object({
 });
 
 // ../../packages/shared/dist/schemas/games.schemas.js
-import { z as z21 } from "zod";
-var Sha256HashSchema = z21.string().regex(/^[0-9a-f]{64}$/, "Expected a lowercase SHA-256 hash");
-var Keccak256HashSchema = z21.string().regex(/^0x[0-9a-fA-F]{64}$/, "Expected a 0x-prefixed Keccak-256 hash");
-var GameStatusSchema = z21.enum(["draft", "published", "hidden"]);
-var GameCoverSourceSchema = z21.enum(["artifact", "catalog_asset"]);
-var GameIdSchema = z21.string().trim().min(1).max(120);
-var GameVoteValueSchema = z21.union([z21.literal(-1), z21.literal(1)]);
-var GameListInputSchema = z21.object({
-  query: z21.string().trim().min(1).max(120).optional(),
-  cursor: z21.string().min(1).max(2048).optional(),
-  limit: z21.number().int().min(1).max(48).optional().default(24)
-});
-var GameGetInputSchema = z21.object({
-  slug: z21.string().trim().min(1).max(120).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, "Game slugs must be lowercase kebab-case")
-});
-var GameVoteInputSchema = z21.object({
+import { z as z22 } from "zod";
+var Sha256HashSchema = z22.string().regex(/^[0-9a-f]{64}$/, "Expected a lowercase SHA-256 hash");
+var Keccak256HashSchema = z22.string().regex(/^0x[0-9a-fA-F]{64}$/, "Expected a 0x-prefixed Keccak-256 hash");
+var GameStatusSchema = z22.enum(["draft", "published", "hidden"]);
+var GameCoverSourceSchema = z22.enum(["artifact", "catalog_asset"]);
+var GameIdSchema = z22.string().trim().min(1).max(120);
+var GameVoteValueSchema = z22.union([z22.literal(-1), z22.literal(1)]);
+var GameListInputSchema = z22.object({
+  query: z22.string().trim().min(1).max(120).optional(),
+  cursor: z22.string().min(1).max(2048).optional(),
+  limit: z22.number().int().min(1).max(48).optional().default(24)
+});
+var GameGetInputSchema = z22.object({
+  slug: z22.string().trim().min(1).max(120).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, "Game slugs must be lowercase kebab-case")
+});
+var GameVoteInputSchema = z22.object({
   gameId: GameIdSchema,
   value: GameVoteValueSchema
 });
-var GameVoteStateInputSchema = z21.object({
+var GameVoteStateInputSchema = z22.object({
   gameId: GameIdSchema
 });
-var GameSourceSchema = z21.object({
-  taskId: z21.string().min(1),
-  submissionId: z21.string().min(1),
-  artifactId: z21.string().min(1),
+var GameSourceSchema = z22.object({
+  taskId: z22.string().min(1),
+  submissionId: z22.string().min(1),
+  artifactId: z22.string().min(1),
   artifactSha256Hash: Sha256HashSchema,
   artifactKeccak256Hash: Keccak256HashSchema,
-  artifactMimeType: z21.string().min(1).max(120),
-  artifactSizeBytes: z21.number().int().nonnegative()
-});
-var GameCatalogFieldsSchema = z21.object({
-  id: z21.string().min(1),
-  slug: z21.string().min(1),
-  title: z21.string().min(1).max(120),
-  description: z21.string().max(2e3).nullable(),
+  artifactMimeType: z22.string().min(1).max(120),
+  artifactSizeBytes: z22.number().int().nonnegative()
+});
+var GameCatalogFieldsSchema = z22.object({
+  id: z22.string().min(1),
+  slug: z22.string().min(1),
+  title: z22.string().min(1).max(120),
+  description: z22.string().max(2e3).nullable(),
   // Optional so a newly deployed catalog client can continue reading responses from an
   // older backend during a rolling release. The backend supplies it once available.
-  taskDescription: z21.string().max(TASK_DESCRIPTION_MAX_LENGTH).optional(),
-  creatorName: z21.string().max(120).nullable(),
-  tags: z21.array(z21.string().min(1).max(64)).max(20),
+  taskDescription: z22.string().max(TASK_DESCRIPTION_MAX_LENGTH).optional(),
+  creatorName: z22.string().max(120).nullable(),
+  tags: z22.array(z22.string().min(1).max(64)).max(20),
   // This is a short-lived delivery URL when the cover can be served. Storage keys and
   // durable storage URIs are deliberately not part of the public catalog contract.
-  coverUrl: z21.string().url().nullable(),
-  coverAltText: z21.string().max(240).nullable(),
-  upvoteCount: z21.number().int().nonnegative(),
-  downvoteCount: z21.number().int().nonnegative(),
-  netVotes: z21.number().int(),
-  publishedAt: z21.string().datetime()
+  coverUrl: z22.string().url().nullable(),
+  coverAltText: z22.string().max(240).nullable(),
+  upvoteCount: z22.number().int().nonnegative(),
+  downvoteCount: z22.number().int().nonnegative(),
+  netVotes: z22.number().int(),
+  publishedAt: z22.string().datetime()
 });
 var GameCatalogItemSchema = GameCatalogFieldsSchema;
 var GameDetailResponseSchema = GameCatalogFieldsSchema.extend({
   source: GameSourceSchema,
   // Minted from the exact pinned artifact only after the backend rechecks the stored hashes.
   // A fresh games.get call refreshes this short-lived URL; storage keys never leave the backend.
-  artifactUrl: z21.string().url().nullable(),
-  artifactUrlExpiresAt: z21.string().datetime().nullable()
+  artifactUrl: z22.string().url().nullable(),
+  artifactUrlExpiresAt: z22.string().datetime().nullable()
 });
-var GameListResponseSchema = z21.object({
-  games: z21.array(GameCatalogItemSchema),
-  nextCursor: z21.string().nullable()
+var GameListResponseSchema = z22.object({
+  games: z22.array(GameCatalogItemSchema),
+  nextCursor: z22.string().nullable()
 });
-var GameVoteResponseSchema = z21.object({
+var GameVoteResponseSchema = z22.object({
   gameId: GameIdSchema,
-  upvoteCount: z21.number().int().nonnegative(),
-  downvoteCount: z21.number().int().nonnegative(),
-  netVotes: z21.number().int(),
+  upvoteCount: z22.number().int().nonnegative(),
+  downvoteCount: z22.number().int().nonnegative(),
+  netVotes: z22.number().int(),
   selectedVote: GameVoteValueSchema.nullable()
 });
 
 // ../../packages/shared/dist/schemas/game-curation.schemas.js
-import { z as z22 } from "zod";
-var Sha256HashSchema2 = z22.string().regex(/^[0-9a-f]{64}$/, "Expected a lowercase SHA-256 hash");
-var Keccak256HashSchema2 = z22.string().regex(/^0x[0-9a-fA-F]{64}$/, "Expected a 0x-prefixed Keccak-256 hash");
+import { z as z23 } from "zod";
+var Sha256HashSchema2 = z23.string().regex(/^[0-9a-f]{64}$/, "Expected a lowercase SHA-256 hash");
+var Keccak256HashSchema2 = z23.string().regex(/^0x[0-9a-fA-F]{64}$/, "Expected a 0x-prefixed Keccak-256 hash");
 var MAX_GAME_COVER_BYTES = 4 * 1024 * 1024;
 var MAX_GAME_COVER_BASE64_CHARS = Math.ceil(MAX_GAME_COVER_BYTES / 3) * 4 + 4;
 function hasAsciiControlCharacter(value) {
@@ -1650,14 +1706,14 @@ function hasAsciiControlCharacter(value) {
     return code <= 31 || code === 127;
   });
 }
-var GameIdSchema2 = z22.string().trim().min(1).max(120);
-var TaskIdSchema = z22.string().trim().min(1).max(160).refine((value) => !hasAsciiControlCharacter(value), "Task ID contains control characters");
-var SlugSchema = z22.string().trim().min(1).max(120).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, "Game slugs must be lowercase kebab-case");
-var TitleSchema = z22.string().trim().min(1).max(120);
-var OptionalTextSchema = z22.string().trim().max(2e3).nullable().optional();
-var OptionalCreatorSchema = z22.string().trim().max(120).nullable().optional();
-var OptionalAltTextSchema = z22.string().trim().max(240).nullable().optional();
-var TagsSchema = z22.array(z22.string().trim().min(1).max(64)).max(20);
+var GameIdSchema2 = z23.string().trim().min(1).max(120);
+var TaskIdSchema = z23.string().trim().min(1).max(160).refine((value) => !hasAsciiControlCharacter(value), "Task ID contains control characters");
+var SlugSchema = z23.string().trim().min(1).max(120).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, "Game slugs must be lowercase kebab-case");
+var TitleSchema = z23.string().trim().min(1).max(120);
+var OptionalTextSchema = z23.string().trim().max(2e3).nullable().optional();
+var OptionalCreatorSchema = z23.string().trim().max(120).nullable().optional();
+var OptionalAltTextSchema = z23.string().trim().max(240).nullable().optional();
+var TagsSchema = z23.array(z23.string().trim().min(1).max(64)).max(20);
 var CANONICAL_TASKMARKET_HOST = "taskmarket.dev";
 function normalizeGameCurationTaskReference(reference) {
   const trimmed = reference.trim();
@@ -1687,64 +1743,64 @@ function normalizeGameCurationTaskReference(reference) {
     throw new Error("Task URL contains an invalid task ID");
   }
 }
-var GameCurationTaskReferenceSchema = z22.string().trim().min(1).max(2048).transform((reference, ctx) => {
+var GameCurationTaskReferenceSchema = z23.string().trim().min(1).max(2048).transform((reference, ctx) => {
   try {
     return normalizeGameCurationTaskReference(reference);
   } catch (error) {
     ctx.addIssue({
-      code: z22.ZodIssueCode.custom,
+      code: z23.ZodIssueCode.custom,
       message: error instanceof Error ? error.message : "Invalid task reference"
     });
-    return z22.NEVER;
+    return z23.NEVER;
   }
 });
-var GameCurationResolveTaskInputSchema = z22.object({
+var GameCurationResolveTaskInputSchema = z23.object({
   // Query-safe on GET requests. It accepts both a raw ID and a canonical public task URL,
   // then stores only the normalized ID in `reference` for the backend resolver.
   reference: GameCurationTaskReferenceSchema
 });
-var GameCurationArtifactSchema = z22.object({
+var GameCurationArtifactSchema = z23.object({
   id: GameIdSchema2,
-  fileName: z22.string().min(1).max(255),
-  mimeType: z22.string().min(1).max(120),
+  fileName: z23.string().min(1).max(255),
+  mimeType: z23.string().min(1).max(120),
   role: ArtifactRole,
-  sizeBytes: z22.number().int().nonnegative(),
+  sizeBytes: z23.number().int().nonnegative(),
   sha256Hash: Sha256HashSchema2,
   keccak256Hash: Keccak256HashSchema2,
-  previewUrl: z22.string().url().nullable(),
-  previewUrlExpiresAt: z22.string().datetime().nullable()
+  previewUrl: z23.string().url().nullable(),
+  previewUrlExpiresAt: z23.string().datetime().nullable()
 });
-var GameCurationSubmissionSchema = z22.object({
+var GameCurationSubmissionSchema = z23.object({
   id: GameIdSchema2,
-  workerAddress: z22.string().min(1),
-  submittedAt: z22.string().datetime(),
-  artifacts: z22.array(GameCurationArtifactSchema)
+  workerAddress: z23.string().min(1),
+  submittedAt: z23.string().datetime(),
+  artifacts: z23.array(GameCurationArtifactSchema)
 });
-var GameCurationResolvedTaskSchema = z22.object({
-  task: z22.object({
+var GameCurationResolvedTaskSchema = z23.object({
+  task: z23.object({
     id: TaskIdSchema,
-    description: z22.string(),
-    status: z22.string(),
-    tags: z22.array(z22.string())
+    description: z23.string(),
+    status: z23.string(),
+    tags: z23.array(z23.string())
   }),
-  eligible: z22.boolean(),
-  eligibilityReason: z22.string().nullable(),
-  submissions: z22.array(GameCurationSubmissionSchema)
+  eligible: z23.boolean(),
+  eligibilityReason: z23.string().nullable(),
+  submissions: z23.array(GameCurationSubmissionSchema)
 });
-var GameCurationArtifactCoverInputSchema = z22.object({
-  source: z22.literal("artifact"),
+var GameCurationArtifactCoverInputSchema = z23.object({
+  source: z23.literal("artifact"),
   artifactId: GameIdSchema2
 });
-var GameCurationCatalogAssetCoverInputSchema = z22.object({
-  source: z22.literal("catalog_asset"),
-  dataBase64: z22.string().min(4).max(MAX_GAME_COVER_BASE64_CHARS),
-  mimeType: z22.enum(["image/png", "image/jpeg", "image/gif", "image/webp"])
+var GameCurationCatalogAssetCoverInputSchema = z23.object({
+  source: z23.literal("catalog_asset"),
+  dataBase64: z23.string().min(4).max(MAX_GAME_COVER_BASE64_CHARS),
+  mimeType: z23.enum(["image/png", "image/jpeg", "image/gif", "image/webp"])
 });
-var GameCurationCoverInputSchema = z22.discriminatedUnion("source", [
+var GameCurationCoverInputSchema = z23.discriminatedUnion("source", [
   GameCurationArtifactCoverInputSchema,
   GameCurationCatalogAssetCoverInputSchema
 ]);
-var GameCurationUpsertInputSchema = z22.object({
+var GameCurationUpsertInputSchema = z23.object({
   gameId: GameIdSchema2.optional(),
   taskId: TaskIdSchema,
   submissionId: GameIdSchema2,
@@ -1758,14 +1814,14 @@ var GameCurationUpsertInputSchema = z22.object({
   coverAltText: OptionalAltTextSchema,
   // Set only after the curator has successfully loaded the exact pin in the shared
   // sandbox. The server records this affirmative, authenticated curator attestation.
-  previewed: z22.boolean().optional()
+  previewed: z23.boolean().optional()
 });
-var GameCurationGameSchema = z22.object({
+var GameCurationGameSchema = z23.object({
   id: GameIdSchema2,
   slug: SlugSchema,
   title: TitleSchema,
-  description: z22.string().nullable(),
-  creatorName: z22.string().nullable(),
+  description: z23.string().nullable(),
+  creatorName: z23.string().nullable(),
   tags: TagsSchema,
   status: GameStatusSchema,
   taskId: TaskIdSchema,
@@ -1773,28 +1829,28 @@ var GameCurationGameSchema = z22.object({
   artifactId: GameIdSchema2,
   artifactSha256Hash: Sha256HashSchema2,
   artifactKeccak256Hash: Keccak256HashSchema2,
-  artifactMimeType: z22.string().min(1).max(120),
-  artifactSizeBytes: z22.number().int().nonnegative(),
+  artifactMimeType: z23.string().min(1).max(120),
+  artifactSizeBytes: z23.number().int().nonnegative(),
   coverSource: GameCoverSourceSchema.nullable(),
   coverArtifactId: GameIdSchema2.nullable(),
   coverSha256Hash: Sha256HashSchema2.nullable(),
-  coverMimeType: z22.string().min(1).max(120).nullable(),
-  coverWidth: z22.number().int().positive().nullable(),
-  coverHeight: z22.number().int().positive().nullable(),
-  coverAltText: z22.string().max(240).nullable(),
-  previewedAt: z22.string().datetime().nullable(),
-  publishedAt: z22.string().datetime().nullable(),
-  hiddenAt: z22.string().datetime().nullable(),
-  createdAt: z22.string().datetime(),
-  updatedAt: z22.string().datetime()
-});
-var GameCurationMutationResponseSchema = z22.object({
+  coverMimeType: z23.string().min(1).max(120).nullable(),
+  coverWidth: z23.number().int().positive().nullable(),
+  coverHeight: z23.number().int().positive().nullable(),
+  coverAltText: z23.string().max(240).nullable(),
+  previewedAt: z23.string().datetime().nullable(),
+  publishedAt: z23.string().datetime().nullable(),
+  hiddenAt: z23.string().datetime().nullable(),
+  createdAt: z23.string().datetime(),
+  updatedAt: z23.string().datetime()
+});
+var GameCurationMutationResponseSchema = z23.object({
   game: GameCurationGameSchema
 });
-var GameCurationPublishInputSchema = z22.object({
+var GameCurationPublishInputSchema = z23.object({
   gameId: GameIdSchema2
 });
-var GameCurationHideInputSchema = z22.object({
+var GameCurationHideInputSchema = z23.object({
   gameId: GameIdSchema2
 });
 
@@ -2690,7 +2746,7 @@ var ApiError = class extends Error {
    * The backend's machine-readable classification of the failure (ADR-0058).
    *
    * Before it existed the CLI rendered every failure identically, which is why
-   * `docs/CLI_GUIDE.md` had to tell script authors never to auto-retry a paid command: there was
+   * `docs/guides/CLI_GUIDE.md` had to tell script authors never to auto-retry a paid command: there was
    * no way to tell a write that is still landing from one that was definitively rejected, and
    * retrying the first is a second payment. `reason` is that way.
    *
@@ -2819,13 +2875,13 @@ async function apiDelete(path7, options) {
 }
 
 // src/lib/x402-errors.ts
-var ExternalX402Error = class extends Error {
+var X402PayError = class extends Error {
   payment;
   pending;
   status;
   constructor(message, options = {}) {
     super(message, options.cause === void 0 ? void 0 : { cause: options.cause });
-    this.name = "ExternalX402Error";
+    this.name = "X402PayError";
     this.payment = options.payment;
     this.pending = options.pending;
     this.status = options.status;
@@ -2842,18 +2898,18 @@ function printResult(data, options) {
 function renderFailure(error, options) {
   const message = error instanceof Error ? error.message : options?.fallback ?? String(error);
   const apiError = error instanceof ApiError ? error : void 0;
-  const externalX402Error = error instanceof ExternalX402Error ? error : void 0;
+  const x402PayError = error instanceof X402PayError ? error : void 0;
   const idempotencyKey = options?.idempotencyKey ?? apiError?.idempotencyKey ?? idempotencyKeyForError(error);
   const envelope = apiError?.envelope;
   process.stderr.write(
     JSON.stringify({
       ok: false,
       error: message,
-      ...apiError !== void 0 ? { status: apiError.status } : externalX402Error?.status !== void 0 ? { status: externalX402Error.status } : {},
+      ...apiError !== void 0 ? { status: apiError.status } : x402PayError?.status !== void 0 ? { status: x402PayError.status } : {},
       ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
       ...envelope !== void 0 ? { ...envelope, pending: isInFlightApiError(envelope) } : {},
-      ...externalX402Error?.pending !== void 0 ? { pending: externalX402Error.pending } : {},
-      ...externalX402Error?.payment !== void 0 ? { payment: externalX402Error.payment } : {},
+      ...x402PayError?.pending !== void 0 ? { pending: x402PayError.pending } : {},
+      ...x402PayError?.payment !== void 0 ? { payment: x402PayError.payment } : {},
       ...options?.details ?? {}
     }) + "\n"
   );
@@ -3500,9 +3556,14 @@ var createCmd = new Command6("create").description("Create a new task (costs rew
 ).option(
   "--auction-floor-price <usdc>",
   "Floor price in USDC for dutch clock (required for dutch)"
-).option("--hook <address>", "ITaskHook contract address (optional)").option(
+).option(
+  "--hook <address>",
+  "Custom ITMPHook contract address (repeat in execution order; protocol defaults run first)",
+  (value, previous = []) => [...previous, value],
+  []
+).option(
   "--hook-data <hex>",
-  "Hook config bytes forwarded to checkFund; encode uint32 as 4 big-endian bytes (e.g. 0x000006b4 for a 1800s TWAP window)"
+  "One shared config value forwarded to checkFund on every hook; encode uint32 as 4 big-endian bytes (e.g. 0x000006b4 for a 1800s TWAP window)"
 ).option("--evaluator <address>", "Evaluator address (optional)").option("--evaluator-fee-bps <bps>", "Evaluator fee in basis points (optional)").option("--evaluation-window <hours>", "Evaluation window in hours (default: 24)").option("--appeal-window <hours>", "Appeal window in hours (default: 24)").option("--dispute-resolver <address>", "Dispute resolver address (optional)").action(
   async (opts) => {
     let rewardBaseUnits;
@@ -3634,14 +3695,53 @@ var createCmd = new Command6("create").description("Create a new task (costs rew
       }
     }
     const ethAddrRe = /^0x[0-9a-fA-F]{40}$/;
-    if (opts.hook && !ethAddrRe.test(opts.hook)) {
-      return void printError("--hook must be a valid Ethereum address (0x + 40 hex chars)");
+    const defaultHookAddressRe = /^0x[0-9a-f]{40}$/i;
+    const hooks = opts.hook ?? [];
+    if (hooks.some((hook) => !ethAddrRe.test(hook) || /^0x0{40}$/i.test(hook))) {
+      return void printError(
+        "--hook must be a non-zero valid Ethereum address (0x + 40 hex chars)"
+      );
+    }
+    if (new Set(hooks.map((hook) => hook.toLowerCase())).size !== hooks.length) {
+      return void printError("--hook addresses must be unique");
+    }
+    if (hooks.length > 8) {
+      return void printError(
+        "--hook accepts at most 8 custom addresses; current protocol defaults count toward the on-chain maximum of 8"
+      );
     }
     if (opts.hookData && !/^0x(?:[0-9a-fA-F]{2})*$/.test(opts.hookData)) {
       return void printError(
         "--hook-data must be a 0x-prefixed hex string with an even number of hex digits"
       );
     }
+    if (hooks.length > 0) {
+      try {
+        const attachmentConfiguration = await apiGet(
+          "/api/hooks/attachment-configuration"
+        );
+        if (attachmentConfiguration !== null && typeof attachmentConfiguration === "object" && !Array.isArray(attachmentConfiguration)) {
+          const { defaultHooks, maxHooks } = attachmentConfiguration;
+          if (Array.isArray(defaultHooks) && typeof maxHooks === "number" && Number.isInteger(maxHooks) && maxHooks > 0 && defaultHooks.every(
+            (hook) => typeof hook === "string" && defaultHookAddressRe.test(hook) && !/^0x0{40}$/i.test(hook)
+          )) {
+            if (hooks.some(
+              (hook) => defaultHooks.some(
+                (defaultHook) => defaultHook.toLowerCase() === hook.toLowerCase()
+              )
+            )) {
+              return void printError("Custom hooks cannot duplicate protocol default hooks.");
+            }
+            if (hooks.length + defaultHooks.length > maxHooks) {
+              return void printError(
+                `Default and custom hooks together cannot exceed ${maxHooks}.`
+              );
+            }
+          }
+        }
+      } catch {
+      }
+    }
     let feeBps;
     if (opts.evaluator) {
       if (!ethAddrRe.test(opts.evaluator)) {
@@ -3661,7 +3761,8 @@ var createCmd = new Command6("create").description("Create a new task (costs rew
         );
       }
     }
-    if (opts.hook) body.hookContract = opts.hook;
+    if (hooks.length === 1) body.hookContract = hooks[0];
+    if (hooks.length > 1) body.hookContracts = hooks;
     if (opts.hookData) body.hookData = opts.hookData;
     if (opts.evaluator) {
       body.evaluator = opts.evaluator;
@@ -7180,99 +7281,99 @@ import { randomUUID as randomUUID5 } from "crypto";
 import { promises as fs6 } from "fs";
 import os5 from "os";
 import path5 from "path";
-import { z as z23 } from "zod";
-var AtomicAmountSchema = z23.string().regex(/^\d+$/, "amount must be an unsigned integer string").refine((value) => BigInt(value) > 0n, "amount must be greater than zero");
-var EvmAddressSchema = z23.string().regex(/^0x[a-fA-F0-9]{40}$/, "invalid EVM address");
-var EvmNetworkSchema = z23.string().regex(/^eip155:[1-9]\d*$/, "network must be an EVM CAIP-2 identifier");
-var EnvironmentVariableSchema = z23.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/, "invalid environment variable name");
-var OriginSchema = z23.string().superRefine((value, ctx) => {
+import { z as z24 } from "zod";
+var AtomicAmountSchema = z24.string().regex(/^\d+$/, "amount must be an unsigned integer string").refine((value) => BigInt(value) > 0n, "amount must be greater than zero");
+var EvmAddressSchema = z24.string().regex(/^0x[a-fA-F0-9]{40}$/, "invalid EVM address");
+var EvmNetworkSchema = z24.string().regex(/^eip155:[1-9]\d*$/, "network must be an EVM CAIP-2 identifier");
+var EnvironmentVariableSchema = z24.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/, "invalid environment variable name");
+var OriginSchema = z24.string().superRefine((value, ctx) => {
   try {
     const parsed = new URL(value);
     if (parsed.protocol !== "https:") {
-      ctx.addIssue({ code: z23.ZodIssueCode.custom, message: "origin must use HTTPS" });
+      ctx.addIssue({ code: z24.ZodIssueCode.custom, message: "origin must use HTTPS" });
     }
     if (parsed.origin !== value || parsed.username || parsed.password) {
-      ctx.addIssue({ code: z23.ZodIssueCode.custom, message: "origin must be an exact URL origin" });
+      ctx.addIssue({ code: z24.ZodIssueCode.custom, message: "origin must be an exact URL origin" });
     }
   } catch {
-    ctx.addIssue({ code: z23.ZodIssueCode.custom, message: "origin must be a valid URL" });
+    ctx.addIssue({ code: z24.ZodIssueCode.custom, message: "origin must be a valid URL" });
   }
 });
-var X402SpendWindowSchema = z23.object({
-  seconds: z23.number().int().positive().max(31536e3),
+var X402SpendWindowSchema = z24.object({
+  seconds: z24.number().int().positive().max(31536e3),
   max: AtomicAmountSchema
 });
-var X402Permit2PolicySchema = z23.object({
-  allowSponsoredApproval: z23.boolean().default(true),
-  allowDirectApproval: z23.boolean().default(false),
-  allowUnattendedDirectApproval: z23.boolean().default(false),
+var X402Permit2PolicySchema = z24.object({
+  allowSponsoredApproval: z24.boolean().default(true),
+  allowDirectApproval: z24.boolean().default(false),
+  allowUnattendedDirectApproval: z24.boolean().default(false),
   maxApprovalGasWei: AtomicAmountSchema.optional()
 });
-var X402PaymentPolicySchema = z23.object({
-  scheme: z23.enum(["exact", "upto"]),
+var X402PaymentPolicySchema = z24.object({
+  scheme: z24.enum(["exact", "upto"]),
   network: EvmNetworkSchema,
   asset: EvmAddressSchema,
   payTo: EvmAddressSchema.optional(),
-  displaySymbol: z23.string().min(1).max(32).optional(),
-  displayDecimals: z23.number().int().min(0).max(255).optional(),
+  displaySymbol: z24.string().min(1).max(32).optional(),
+  displayDecimals: z24.number().int().min(0).max(255).optional(),
   maxPerPayment: AtomicAmountSchema,
   spendWindow: X402SpendWindowSchema,
   permit2: X402Permit2PolicySchema.optional()
 }).superRefine((value, ctx) => {
   if (BigInt(value.maxPerPayment) > BigInt(value.spendWindow.max)) {
     ctx.addIssue({
-      code: z23.ZodIssueCode.custom,
+      code: z24.ZodIssueCode.custom,
       message: "maxPerPayment must not exceed spendWindow.max",
       path: ["maxPerPayment"]
     });
   }
   if (value.permit2?.allowUnattendedDirectApproval && !value.permit2.allowDirectApproval) {
     ctx.addIssue({
-      code: z23.ZodIssueCode.custom,
+      code: z24.ZodIssueCode.custom,
       message: "unattended direct approval requires allowDirectApproval",
       path: ["permit2", "allowUnattendedDirectApproval"]
     });
   }
 });
-var X402PolicyRuleSchema = z23.object({
-  id: z23.string().regex(/^[a-z0-9][a-z0-9._-]{0,63}$/, "invalid rule id"),
-  enabled: z23.boolean().default(true),
-  priority: z23.number().int().default(0),
+var X402PolicyRuleSchema = z24.object({
+  id: z24.string().regex(/^[a-z0-9][a-z0-9._-]{0,63}$/, "invalid rule id"),
+  enabled: z24.boolean().default(true),
+  priority: z24.number().int().default(0),
   origin: OriginSchema,
-  pathPrefix: z23.string().startsWith("/").default("/"),
-  methods: z23.array(z23.enum(["GET", "POST"])).min(1),
-  unattended: z23.boolean().default(false),
-  allowPrivateNetwork: z23.boolean().default(false),
-  maxAuthorizationSeconds: z23.number().int().positive().max(3600).default(300),
-  payments: z23.array(X402PaymentPolicySchema).min(1)
+  pathPrefix: z24.string().startsWith("/").default("/"),
+  methods: z24.array(z24.enum(["GET", "POST"])).min(1),
+  unattended: z24.boolean().default(false),
+  allowPrivateNetwork: z24.boolean().default(false),
+  maxAuthorizationSeconds: z24.number().int().positive().max(3600).default(300),
+  payments: z24.array(X402PaymentPolicySchema).min(1)
 }).superRefine((value, ctx) => {
   if (!value.unattended) return;
   value.payments.forEach((payment, index) => {
     if (!payment.payTo) {
       ctx.addIssue({
-        code: z23.ZodIssueCode.custom,
+        code: z24.ZodIssueCode.custom,
         message: "unattended payment entries must pin payTo",
         path: ["payments", index, "payTo"]
       });
     }
   });
 });
-var X402PolicySchema = z23.object({
-  version: z23.literal(1),
-  networks: z23.record(
+var X402PolicySchema = z24.object({
+  version: z24.literal(1),
+  networks: z24.record(
     EvmNetworkSchema,
-    z23.object({
+    z24.object({
       rpcUrlEnv: EnvironmentVariableSchema
     })
   ),
-  rules: z23.array(X402PolicyRuleSchema)
+  rules: z24.array(X402PolicyRuleSchema)
 }).superRefine((value, ctx) => {
   const ids = /* @__PURE__ */ new Set();
   for (let index = 0; index < value.rules.length; index += 1) {
     const rule = value.rules[index];
     if (ids.has(rule.id)) {
       ctx.addIssue({
-        code: z23.ZodIssueCode.custom,
+        code: z24.ZodIssueCode.custom,
         message: `duplicate rule id: ${rule.id}`,
         path: ["rules", index, "id"]
       });
@@ -7281,7 +7382,7 @@ var X402PolicySchema = z23.object({
     for (const payment of rule.payments) {
       if (!value.networks[payment.network]) {
         ctx.addIssue({
-          code: z23.ZodIssueCode.custom,
+          code: z24.ZodIssueCode.custom,
           message: `network ${payment.network} has no RPC configuration`,
           path: ["rules", index, "payments"]
         });
@@ -7696,7 +7797,7 @@ async function confirmManualResolution() {
   return answer.trim().toLowerCase() === "resolve";
 }
 var x402PaymentsCommand = new Command71("payments").description(
-  "Inspect and reconcile external x402 payment records"
+  "Inspect and reconcile X402 Pay payment records"
 );
 x402PaymentsCommand.command("list").description("List current payment records").addOption(new Option2("--state <state>", "Filter by state").choices(PAYMENT_STATES)).action(async (options) => {
   const payments = await listX402Payments({ state: options.state });
@@ -7746,7 +7847,7 @@ async function confirmUnattendedRule(rule) {
   return answer.trim().toLowerCase() === "authorize";
 }
 var x402PolicyCommand = new Command72("policy").description(
-  "Manage local external x402 spending policy"
+  "Manage local X402 Pay spending policy"
 );
 x402PolicyCommand.command("init").description("Create a deny-all policy file").action(async () => {
   const policy = await initializeX402Policy();
@@ -7784,7 +7885,7 @@ for (const enabled of [true, false]) {
 import { Command as Command73, Option as Option3 } from "commander";
 import { createInterface as createInterface5 } from "readline";
 
-// src/lib/external-x402-client.ts
+// src/lib/x402-pay-client.ts
 import { x402Client } from "@x402/core/client";
 import { ExactEvmScheme } from "@x402/evm/exact/client";
 import { UptoEvmScheme } from "@x402/evm/upto/client";
@@ -7807,7 +7908,7 @@ var FORBIDDEN_HEADERS = /* @__PURE__ */ new Set([
   "payment-signature",
   "transfer-encoding"
 ]);
-function parseExternalX402Url(raw) {
+function parseX402PayUrl(raw) {
   let url;
   try {
     url = new URL(raw);
@@ -7842,7 +7943,7 @@ function isPrivateNetworkAddress(address) {
   if (family === 6) return isPrivateIpv6(address);
   return true;
 }
-async function validateExternalX402Destination(url, options) {
+async function validateX402PayDestination(url, options) {
   const resolve = options.resolve ?? dns.lookup;
   const addresses = await resolve(url.hostname, { all: true, verbatim: true });
   if (addresses.length === 0)
@@ -7914,7 +8015,7 @@ async function loadExternalHeaders(input) {
   return result;
 }
 async function prepareX402HttpRequest(input) {
-  const url = parseExternalX402Url(input.rawUrl);
+  const url = parseX402PayUrl(input.rawUrl);
   const method = input.method.toUpperCase();
   if (method !== "GET" && method !== "POST") throw new Error("x402 method must be GET or POST");
   if (input.json !== void 0 && input.bodyFile) {
@@ -8321,7 +8422,7 @@ function authorizationKindFromPaymentPayload(payload) {
   return void 0;
 }
 
-// src/lib/external-x402-client.ts
+// src/lib/x402-pay-client.ts
 function sameRequirement(left, right) {
   return left.scheme === right.scheme && left.network === right.network && left.amount === right.amount && left.asset.toLowerCase() === right.asset.toLowerCase() && left.payTo.toLowerCase() === right.payTo.toLowerCase();
 }
@@ -8438,7 +8539,7 @@ function signerFor(account) {
     signTypedData: async (typedData) => account.signTypedData(typedData)
   };
 }
-async function executeExternalX402Request(options) {
+async function executeX402PayRequest(options) {
   const nonInteractive = Boolean(options.nonInteractive);
   const request = await prepareX402HttpRequest({
     rawUrl: options.rawUrl,
@@ -8456,7 +8557,7 @@ async function executeExternalX402Request(options) {
     request,
     requestedRuleId: options.policyRuleId
   });
-  await validateExternalX402Destination(request.url, { allowPrivateNetwork });
+  await validateX402PayDestination(request.url, { allowPrivateNetwork });
   const account = options.account ?? await createWalletAccountFromKeystore(await loadKeystore());
   const rpcOptions = rpcConfigurationByChainId(policy);
   let selectedAuthorization;
@@ -8637,7 +8738,7 @@ async function executeExternalX402Request(options) {
   const guardedFetch = async (input, init) => {
     const outgoing = new Request(input, { ...init, redirect: "error" });
     const isPaid = outgoing.headers.has("payment-signature") || outgoing.headers.has("x-payment");
-    await validateExternalX402Destination(request.url, { allowPrivateNetwork });
+    await validateX402PayDestination(request.url, { allowPrivateNetwork });
     if (isPaid) {
       if (!paymentRecord) throw new Error("Paid x402 request has no journal reservation");
       paidRequestDispatched = true;
@@ -8651,7 +8752,7 @@ async function executeExternalX402Request(options) {
           state: "unknown",
           error: error instanceof Error ? error.message : String(error)
         });
-        throw new ExternalX402Error("External x402 outcome is unknown; do not retry", {
+        throw new X402PayError("External x402 outcome is unknown; do not retry", {
           cause: error,
           payment: paymentRecord,
           pending: true
@@ -8670,7 +8771,7 @@ async function executeExternalX402Request(options) {
       redirect: "error"
     });
   } catch (error) {
-    if (error instanceof ExternalX402Error) throw error;
+    if (error instanceof X402PayError) throw error;
     if (paymentRecord) {
       const current = await getX402Payment(paymentRecord.id);
       if (["ready", "dispatched", "unknown"].includes(current.state) || paidRequestDispatched) {
@@ -8678,14 +8779,14 @@ async function executeExternalX402Request(options) {
           state: "unknown",
           error: error instanceof Error ? error.message : String(error)
         });
-        throw new ExternalX402Error("External x402 outcome is unknown; do not retry", {
+        throw new X402PayError("External x402 outcome is unknown; do not retry", {
           cause: error,
           payment: paymentRecord,
           pending: true
         });
       }
     }
-    throw new ExternalX402Error(
+    throw new X402PayError(
       error instanceof Error ? error.message : "External x402 request failed",
       { cause: error, payment: paymentRecord, pending: false }
     );
@@ -8693,7 +8794,7 @@ async function executeExternalX402Request(options) {
   if (paymentRecord) {
     paymentRecord = await getX402Payment(paymentRecord.id);
     if (paymentRecord.state !== "settled") {
-      throw new ExternalX402Error("External x402 outcome is unknown; do not retry", {
+      throw new X402PayError("External x402 outcome is unknown; do not retry", {
         payment: paymentRecord,
         pending: true,
         status: response.status
@@ -8705,7 +8806,7 @@ async function executeExternalX402Request(options) {
     responseData = await externalResponseData(response, { outputPath: options.outputPath });
   } catch (error) {
     if (paymentRecord) {
-      throw new ExternalX402Error(
+      throw new X402PayError(
         error instanceof Error ? error.message : "Failed to process external response",
         { cause: error, payment: paymentRecord, pending: false, status: response.status }
       );
@@ -8713,7 +8814,7 @@ async function executeExternalX402Request(options) {
     throw error;
   }
   if (!response.ok) {
-    throw new ExternalX402Error(`External service returned HTTP ${response.status}`, {
+    throw new X402PayError(`External service returned HTTP ${response.status}`, {
       payment: paymentRecord,
       pending: false,
       status: response.status
@@ -8739,7 +8840,7 @@ async function confirm(lines) {
   readline.close();
   return answer.trim().toLowerCase() === "yes";
 }
-var x402RequestCommand = new Command73("request").description("Request and pay for a direct external x402 HTTP resource").argument("<url>", "HTTPS resource URL").addOption(new Option3("--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 Command73("request").description("Request and pay for a direct x402 HTTP resource (X402 Pay)").argument("<url>", "HTTPS resource URL").addOption(new Option3("--method <method>", "HTTP method").choices(["GET", "POST"]).default("GET")).option("--json <json>", "Inline JSON POST body").option("--body-file <path>", "Read JSON POST body from a file").option("--headers-file <path>", "Read request headers from an owner-only JSON file").option(
   "--header-env <header=ENV_VAR>",
   "Read one request header from an environment variable (repeatable)",
   collect2,
@@ -8750,7 +8851,7 @@ var x402RequestCommand = new Command73("request").description("Request and pay f
       headersFile: options.headersFile,
       headerEnv: options.headerEnv
     });
-    const result = await executeExternalX402Request({
+    const result = await executeX402PayRequest({
       rawUrl: url,
       method: options.method,
       json: options.json,
@@ -8784,7 +8885,7 @@ var x402RequestCommand = new Command73("request").description("Request and pay f
 
 // src/commands/x402/index.ts
 var x402Command = new Command74("x402").description(
-  "Pay external x402 services with local spending policies"
+  "Pay x402 services with local spending policies (X402 Pay)"
 );
 x402Command.addCommand(x402RequestCommand);
 x402Command.addCommand(x402PolicyCommand);