@agentrade/cli 0.1.0

package/dist/index.js

@@ -0,0 +1,3447 @@
+#!/usr/bin/env node
+
+// src/program.ts
+import { Command } from "commander";
+
+// ../../packages/config/src/index.ts
+var envString = (key, fallback) => {
+  const raw = process.env[key];
+  return raw && raw.length > 0 ? raw : fallback;
+};
+var PLACEHOLDER_VALUES = {
+  JWT_SECRET: "replace-this-secret",
+  ADMIN_SERVICE_KEY: "replace-this-admin-key"
+};
+var defaultConfig = {
+  appName: "Agentrade",
+  host: "0.0.0.0",
+  port: 3e3,
+  apiDefaultVersion: "v2",
+  databaseUrl: "postgresql://postgres:postgres@localhost:5432/agentrade",
+  redisUrl: "redis://localhost:6379",
+  enablePersistence: true,
+  enableRedisRateLimit: true,
+  trustProxy: false,
+  corsAllowedOrigins: [
+    "http://localhost:3000",
+    "http://127.0.0.1:3000",
+    "http://localhost:3001",
+    "http://127.0.0.1:3001"
+  ],
+  jwtSecret: PLACEHOLDER_VALUES.JWT_SECRET,
+  adminServiceKey: PLACEHOLDER_VALUES.ADMIN_SERVICE_KEY,
+  authChallengeTtlMinutes: 10,
+  authChallengeMaxEntries: 1e4,
+  authChallengeSweepIntervalMs: 3e4,
+  rateLimitPerMinute: 300,
+  rateLimitBurst: 60,
+  taskTitleMaxLength: 200,
+  taskDescriptionMaxLength: 2e4,
+  taskAcceptanceCriteriaMaxLength: 8e3,
+  taskSubmissionPayloadMaxLength: 2e4,
+  taskSubmissionAttachmentMaxCount: 10,
+  taskSubmissionAttachmentNameMaxLength: 200,
+  taskSubmissionAttachmentUrlMaxLength: 2e3,
+  taskSubmissionAttachmentMaxSizeBytes: 100 * 1024 * 1024,
+  disputeReasonMaxLength: 4e3,
+  taskSlotsMax: 100,
+  taskRewardPerSlotMax: 1e6,
+  taskDeadlineMaxHours: 4320,
+  taxRateBps: 500,
+  taxMin: 1,
+  rewardMin: 1,
+  initialAgentBalance: 1e3,
+  mintPerCycle: 1e4,
+  taskCompletionPublisherWorkload: 0.25,
+  taskCompletionWorkerWorkload: 0.25,
+  terminationPenaltyBps: 1e3,
+  submissionTimeoutHours: 72,
+  resubmitCooldownMinutes: 30,
+  disputeQuorum: 5,
+  disputeApprovalBps: 6e3,
+  reputationWeightPublisherBps: 2e3,
+  reputationWeightWorkerBps: 3e3,
+  reputationWeightSupervisorBps: 5e3,
+  scoreWeightReputationBps: 4500,
+  scoreWeightCompletionBps: 3500,
+  scoreWeightQualityBps: 2e3,
+  bridgeChain: "Base Sepolia",
+  bridgeMode: "OFFCHAIN_EXPORT_ONLY"
+};
+var loadCliRuntimeConfig = () => ({
+  apiBaseUrl: envString("AGENTRADE_API_BASE_URL", "https://agentrade.info"),
+  token: process.env.AGENTRADE_TOKEN,
+  adminServiceKey: process.env.AGENTRADE_ADMIN_SERVICE_KEY,
+  timeoutMs: envString("AGENTRADE_TIMEOUT_MS", "10000"),
+  retries: envString("AGENTRADE_RETRIES", "1")
+});
+
+// src/operation-bindings.ts
+var cliOperationBindings = {
+  "activities list": "activitiesListV2",
+  "admin bridge export": "adminBridgeExportV2",
+  "admin cycles close": "adminCloseCycleV2",
+  "admin disputes override": "adminOverrideDisputeV2",
+  "agents list": "agentsListV2",
+  "agents profile get": "agentsGetProfileV2",
+  "agents profile update": "agentsUpdateProfileV2",
+  "agents stats": "agentsGetStatsV2",
+  "auth challenge": "authChallengeV2",
+  "auth verify": "authVerifyV2",
+  "cycles active": "cyclesGetActiveV2",
+  "cycles get": "cyclesGetV2",
+  "cycles list": "cyclesListV2",
+  "cycles rewards": "cyclesGetRewardsV2",
+  "dashboard summary": "dashboardSummaryV2",
+  "dashboard trends": "dashboardTrendsV2",
+  "disputes get": "disputesGetV2",
+  "disputes list": "disputesListV2",
+  "disputes open": "disputesOpenV2",
+  "disputes vote": "disputesVoteV2",
+  "economy params": "economyGetParamsV2",
+  "ledger get": "ledgerGetV2",
+  "submissions get": "submissionsGetV2",
+  "submissions list": "submissionsListV2",
+  "submissions confirm": "submissionsConfirmV2",
+  "submissions reject": "submissionsRejectV2",
+  "system health": "systemHealthV2",
+  "tasks create": "tasksCreateV2",
+  "tasks get": "tasksGetV2",
+  "tasks intend": "tasksAddIntentionV2",
+  "tasks intentions": "tasksListIntentionsV2",
+  "tasks list": "tasksListV2",
+  "tasks submit": "tasksSubmitV2",
+  "tasks terminate": "tasksTerminateV2"
+};
+
+// src/text-input.ts
+import { readFileSync } from "fs";
+
+// src/errors.ts
+var CliValidationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CliValidationError";
+  }
+};
+var CliConfigError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CliConfigError";
+  }
+};
+
+// src/text-input.ts
+var resolveTextInput = (options) => {
+  const { inlineValue, filePath, fieldName, required = true, allowEmpty = false } = options;
+  if (inlineValue !== void 0 && filePath !== void 0) {
+    throw new CliValidationError(`--${fieldName} and --${fieldName}-file are mutually exclusive`);
+  }
+  let value;
+  if (filePath !== void 0) {
+    try {
+      value = readFileSync(filePath, "utf8");
+    } catch (error) {
+      throw new CliValidationError(
+        `failed to read --${fieldName}-file: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  } else {
+    value = inlineValue;
+  }
+  if (value === void 0) {
+    if (required) {
+      throw new CliValidationError(`--${fieldName} or --${fieldName}-file is required`);
+    }
+    return void 0;
+  }
+  if (!allowEmpty && value.trim().length === 0) {
+    throw new CliValidationError(`--${fieldName} must be non-empty`);
+  }
+  return value;
+};
+
+// ../../packages/types/src/index.ts
+var TaskStatus = /* @__PURE__ */ ((TaskStatus2) => {
+  TaskStatus2["OPEN"] = "OPEN";
+  TaskStatus2["IN_PROGRESS"] = "IN_PROGRESS";
+  TaskStatus2["TERMINATED"] = "TERMINATED";
+  TaskStatus2["CLOSED"] = "CLOSED";
+  return TaskStatus2;
+})(TaskStatus || {});
+var SubmissionStatus = /* @__PURE__ */ ((SubmissionStatus2) => {
+  SubmissionStatus2["SUBMITTED"] = "SUBMITTED";
+  SubmissionStatus2["CONFIRMED"] = "CONFIRMED";
+  SubmissionStatus2["REJECTED"] = "REJECTED";
+  return SubmissionStatus2;
+})(SubmissionStatus || {});
+var DisputeStatus = /* @__PURE__ */ ((DisputeStatus2) => {
+  DisputeStatus2["OPEN"] = "OPEN";
+  DisputeStatus2["RESOLVED_COMPLETED"] = "RESOLVED_COMPLETED";
+  return DisputeStatus2;
+})(DisputeStatus || {});
+var VoteChoice = /* @__PURE__ */ ((VoteChoice2) => {
+  VoteChoice2["COMPLETED"] = "COMPLETED";
+  VoteChoice2["NOT_COMPLETED"] = "NOT_COMPLETED";
+  return VoteChoice2;
+})(VoteChoice || {});
+var CycleStatus = /* @__PURE__ */ ((CycleStatus2) => {
+  CycleStatus2["OPEN"] = "OPEN";
+  CycleStatus2["CLOSED"] = "CLOSED";
+  return CycleStatus2;
+})(CycleStatus || {});
+var ActivityEventType = /* @__PURE__ */ ((ActivityEventType2) => {
+  ActivityEventType2["TASK_PUBLISHED"] = "TASK_PUBLISHED";
+  ActivityEventType2["TASK_INTENDED"] = "TASK_INTENDED";
+  ActivityEventType2["TASK_SUBMITTED"] = "TASK_SUBMITTED";
+  ActivityEventType2["SUBMISSION_REJECTED"] = "SUBMISSION_REJECTED";
+  ActivityEventType2["TASK_COMPLETED"] = "TASK_COMPLETED";
+  ActivityEventType2["DISPUTE_OPENED"] = "DISPUTE_OPENED";
+  ActivityEventType2["TASK_TERMINATED"] = "TASK_TERMINATED";
+  return ActivityEventType2;
+})(ActivityEventType || {});
+
+// src/validators.ts
+var ADDRESS_REGEX = /^0x[a-fA-F0-9]{40}$/;
+var ISO_DATETIME_REGEX = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?(?:Z|[+-]\d{2}:\d{2})$/;
+var parseInteger = (raw, flag) => {
+  if (!/^[-]?\d+$/.test(raw.trim())) {
+    throw new CliValidationError(`${flag} must be an integer`);
+  }
+  const parsed = Number(raw);
+  if (!Number.isSafeInteger(parsed)) {
+    throw new CliValidationError(`${flag} must be a safe integer`);
+  }
+  return parsed;
+};
+var ensureAddress = (raw, flag) => {
+  if (!ADDRESS_REGEX.test(raw)) {
+    throw new CliValidationError(`${flag} must be a valid EVM address`);
+  }
+  return raw;
+};
+var ensureNonEmpty = (raw, flag) => {
+  if (raw.trim().length === 0) {
+    throw new CliValidationError(`${flag} must be non-empty`);
+  }
+  return raw;
+};
+var ensureIsoDate = (raw, flag) => {
+  const value = raw.trim();
+  if (!ISO_DATETIME_REGEX.test(value)) {
+    throw new CliValidationError(`${flag} must be a valid ISO datetime with timezone`);
+  }
+  const timestamp = Date.parse(value);
+  if (!Number.isFinite(timestamp)) {
+    throw new CliValidationError(`${flag} must be a valid ISO datetime`);
+  }
+  return new Date(timestamp).toISOString();
+};
+var ensureIanaTimeZone = (raw, flag) => {
+  const value = raw.trim();
+  if (value.length === 0) {
+    throw new CliValidationError(`${flag} must be non-empty`);
+  }
+  try {
+    Intl.DateTimeFormat("en-US", { timeZone: value });
+  } catch {
+    throw new CliValidationError(`${flag} must be a valid IANA timezone`);
+  }
+  return value;
+};
+var ensureHttpUrl = (raw, flag) => {
+  const value = raw.trim();
+  if (value.length === 0) {
+    throw new CliValidationError(`${flag} must be non-empty`);
+  }
+  let parsed;
+  try {
+    parsed = new URL(value);
+  } catch {
+    throw new CliValidationError(`${flag} must be a valid URL`);
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    throw new CliValidationError(`${flag} must start with http:// or https://`);
+  }
+  return value;
+};
+var ensurePositiveInteger = (raw, flag) => {
+  const value = parseInteger(raw, flag);
+  if (value <= 0) {
+    throw new CliValidationError(`${flag} must be > 0`);
+  }
+  return value;
+};
+var ensureNonNegativeInteger = (raw, flag) => {
+  const value = parseInteger(raw, flag);
+  if (value < 0) {
+    throw new CliValidationError(`${flag} must be >= 0`);
+  }
+  return value;
+};
+var ensureVoteChoice = (raw) => {
+  const normalized = raw.trim().toUpperCase();
+  if (normalized !== "COMPLETED" /* COMPLETED */ && normalized !== "NOT_COMPLETED" /* NOT_COMPLETED */) {
+    throw new CliValidationError("--vote must be COMPLETED or NOT_COMPLETED");
+  }
+  return normalized;
+};
+var ensureOverrideResult = (raw) => {
+  const normalized = raw.trim().toUpperCase();
+  if (normalized !== "COMPLETED" && normalized !== "NOT_COMPLETED") {
+    throw new CliValidationError("--result must be COMPLETED or NOT_COMPLETED");
+  }
+  return normalized;
+};
+var parseOptionalAddressList = (raw, flag) => {
+  if (!raw || raw.trim().length === 0) {
+    return void 0;
+  }
+  const values = raw.split(/[\s,]+/).map((item) => item.trim()).filter((item) => item.length > 0);
+  if (values.length === 0) {
+    return void 0;
+  }
+  const unique = [...new Set(values)];
+  return unique.map((value) => ensureAddress(value, flag));
+};
+
+// ../../packages/contracts/src/schemas.ts
+import { z } from "zod";
+var ADDRESS_PATTERN = "^0x[a-fA-F0-9]{40}$";
+var addressExample = "0x1111111111111111111111111111111111111111";
+var isoDateExample = "2026-04-02T08:00:00.000Z";
+var defineSchema = (name, schema, openapi) => ({
+  name,
+  schema,
+  openapi
+});
+var schemaRef = (schema) => ({
+  $ref: `#/components/schemas/${typeof schema === "string" ? schema : schema.name}`
+});
+var addressField = {
+  type: "string",
+  pattern: ADDRESS_PATTERN,
+  example: addressExample
+};
+var isoDateField = {
+  type: "string",
+  format: "date-time",
+  example: isoDateExample
+};
+var boolField = { type: "boolean" };
+var stringField = { type: "string" };
+var nonEmptyStringField = { type: "string", minLength: 1 };
+var integerField = { type: "integer" };
+var numberField = { type: "number" };
+var addressSchema = z.string().regex(new RegExp(ADDRESS_PATTERN));
+var isoDateSchema = z.string().datetime();
+var nonEmptyStringSchema = z.string().trim().min(1);
+var nullableIsoDateOpenApi = { ...isoDateField, nullable: true };
+var addressArrayOpenApi = { type: "array", items: { ...addressField } };
+var reputationTripleSchema = defineSchema(
+  "ReputationTriple",
+  z.object({
+    publisher: z.number(),
+    worker: z.number(),
+    supervisor: z.number()
+  }),
+  {
+    type: "object",
+    additionalProperties: false,
+    required: ["publisher", "worker", "supervisor"],
+    properties: {
+      publisher: { ...numberField },
+      worker: { ...numberField },
+      supervisor: { ...numberField }
+    }
+  }
+);
+var agentStatsSchema = defineSchema(
+  "AgentStats",
+  z.object({
+    tasksPublished: z.number().int(),
+    tasksIntented: z.number().int(),
+    tasksCompleted: z.number().int(),
+    tasksTerminated: z.number().int(),
+    submissionsRejected: z.number().int(),
+    supervisionVotes: z.number().int()
+  }),
+  {
+    type: "object",
+    additionalProperties: false,
+    required: [
+      "tasksPublished",
+      "tasksIntented",
+      "tasksCompleted",
+      "tasksTerminated",
+      "submissionsRejected",
+      "supervisionVotes"
+    ],
+    properties: {
+      tasksPublished: { ...integerField },
+      tasksIntented: { ...integerField },
+      tasksCompleted: { ...integerField },
+      tasksTerminated: { ...integerField },
+      submissionsRejected: { ...integerField },
+      supervisionVotes: { ...integerField }
+    }
+  }
+);
+var agentProfileSchema = defineSchema(
+  "AgentProfile",
+  z.object({
+    address: addressSchema,
+    name: z.string(),
+    bio: z.string(),
+    reputation: reputationTripleSchema.schema,
+    stats: agentStatsSchema.schema,
+    createdAt: isoDateSchema,
+    updatedAt: isoDateSchema
+  }),
+  {
+    type: "object",
+    additionalProperties: false,
+    required: ["address", "name", "bio", "reputation", "stats", "createdAt", "updatedAt"],
+    properties: {
+      address: { ...addressField },
+      name: { ...stringField },
+      bio: { ...stringField },
+      reputation: schemaRef(reputationTripleSchema),
+      stats: schemaRef(agentStatsSchema),
+      createdAt: { ...isoDateField },
+      updatedAt: { ...isoDateField }
+    }
+  }
+);
+var taskSchema = defineSchema(
+  "Task",
+  z.object({
+    id: z.string(),
+    publisher: addressSchema,
+    title: z.string(),
+    descriptionMd: z.string(),
+    acceptanceCriteria: z.string(),
+    status: z.nativeEnum(TaskStatus),
+    deadlineUtc: isoDateSchema,
+    displayTimezone: z.string(),
+    slotsTotal: z.number().int(),
+    rewardPerSlot: z.number().int(),
+    allowRepeatCompletionsBySameAgent: z.boolean(),
+    taxAmount: z.number().int(),
+    rewardEscrowRemaining: z.number().int(),
+    intentCount: z.number().int(),
+    competitionRatio: z.number(),
+    completedAgents: z.array(addressSchema),
+    createdAt: isoDateSchema,
+    updatedAt: isoDateSchema
+  }),
+  {
+    type: "object",
+    additionalProperties: false,
+    required: [
+      "id",
+      "publisher",
+      "title",
+      "descriptionMd",
+      "acceptanceCriteria",
+      "status",
+      "deadlineUtc",
+      "displayTimezone",
+      "slotsTotal",
+      "rewardPerSlot",
+      "allowRepeatCompletionsBySameAgent",
+      "taxAmount",
+      "rewardEscrowRemaining",
+      "intentCount",
+      "competitionRatio",
+      "completedAgents",
+      "createdAt",
+      "updatedAt"
+    ],
+    properties: {
+      id: { ...stringField },
+      publisher: { ...addressField },
+      title: { ...stringField },
+      descriptionMd: { ...stringField },
+      acceptanceCriteria: { ...stringField },
+      status: {
+        type: "string",
+        enum: Object.values(TaskStatus)
+      },
+      deadlineUtc: { ...isoDateField },
+      displayTimezone: { ...stringField },
+      slotsTotal: { ...integerField },
+      rewardPerSlot: { ...integerField },
+      allowRepeatCompletionsBySameAgent: { ...boolField },
+      taxAmount: { ...integerField },
+      rewardEscrowRemaining: { ...integerField },
+      intentCount: { ...integerField },
+      competitionRatio: { ...numberField },
+      completedAgents: { ...addressArrayOpenApi },
+      createdAt: { ...isoDateField },
+      updatedAt: { ...isoDateField }
+    }
+  }
+);
+var taskIntentionSchema = defineSchema(
+  "TaskIntention",
+  z.object({
+    id: z.string(),
+    taskId: z.string(),
+    agent: addressSchema,
+    createdAt: isoDateSchema
+  }),
+  {
+    type: "object",
+    additionalProperties: false,
+    required: ["id", "taskId", "agent", "createdAt"],
+    properties: {
+      id: { ...stringField },
+      taskId: { ...stringField },
+      agent: { ...addressField },
+      createdAt: { ...isoDateField }
+    }
+  }
+);
+var submissionAttachmentSchema = defineSchema(
+  "SubmissionAttachment",
+  z.object({
+    name: nonEmptyStringSchema,
+    url: z.string().url(),
+    mimeType: z.string().trim().min(1).optional(),
+    sizeBytes: z.number().int().nonnegative().optional()
+  }),
+  {
+    type: "object",
+    additionalProperties: false,
+    required: ["name", "url"],
+    properties: {
+      name: { ...nonEmptyStringField },
+      url: { ...stringField, format: "uri" },
+      mimeType: { ...nonEmptyStringField },
+      sizeBytes: { ...integerField, minimum: 0 }
+    }
+  }
+);
+var submissionSchema = defineSchema(
+  "Submission",
+  z.object({
+    id: z.string(),
+    taskId: z.string(),
+    agent: addressSchema,
+    payloadMd: z.string(),
+    attachments: z.array(submissionAttachmentSchema.schema),
+    status: z.nativeEnum(SubmissionStatus),
+    createdAt: isoDateSchema,
+    updatedAt: isoDateSchema
+  }),
+  {
+    type: "object",
+    additionalProperties: false,
+    required: ["id", "taskId", "agent", "payloadMd", "attachments", "status", "createdAt", "updatedAt"],
+    properties: {
+      id: { ...stringField },
+      taskId: { ...stringField },
+      agent: { ...addressField },
+      payloadMd: { ...stringField },
+      attachments: {
+        type: "array",
+        items: schemaRef(submissionAttachmentSchema)
+      },
+      status: {
+        type: "string",
+        enum: Object.values(SubmissionStatus)
+      },
+      createdAt: { ...isoDateField },
+      updatedAt: { ...isoDateField }
+    }
+  }
+);
+var disputeSchema = defineSchema(
+  "Dispute",
+  z.object({
+    id: z.string(),
+    taskId: z.string(),
+    submissionId: z.string(),
+    opener: addressSchema,
+    reasonMd: z.string(),
+    status: z.nativeEnum(DisputeStatus),
+    resolution: z.object({
+      totalVotes: z.number().int().nonnegative(),
+      completedVotes: z.number().int().nonnegative(),
+      notCompletedVotes: z.number().int().nonnegative(),
+      outcome: z.nativeEnum(VoteChoice),
+      winnerRole: z.enum(["PUBLISHER", "SUBMISSION_AGENT"]),
+      winnerAddress: addressSchema
+    }).optional(),
+    createdAt: isoDateSchema,
+    updatedAt: isoDateSchema
+  }),
+  {
+    type: "object",
+    additionalProperties: false,
+    required: ["id", "taskId", "submissionId", "opener", "reasonMd", "status", "createdAt", "updatedAt"],
+    properties: {
+      id: { ...stringField },
+      taskId: { ...stringField },
+      submissionId: { ...stringField },
+      opener: { ...addressField },
+      reasonMd: { ...stringField },
+      status: {
+        type: "string",
+        enum: Object.values(DisputeStatus)
+      },
+      resolution: {
+        type: "object",
+        additionalProperties: false,
+        required: [
+          "totalVotes",
+          "completedVotes",
+          "notCompletedVotes",
+          "outcome",
+          "winnerRole",
+          "winnerAddress"
+        ],
+        properties: {
+          totalVotes: { ...integerField, minimum: 0 },
+          completedVotes: { ...integerField, minimum: 0 },
+          notCompletedVotes: { ...integerField, minimum: 0 },
+          outcome: {
+            type: "string",
+            enum: Object.values(VoteChoice)
+          },
+          winnerRole: {
+            type: "string",
+            enum: ["PUBLISHER", "SUBMISSION_AGENT"]
+          },
+          winnerAddress: { ...addressField }
+        }
+      },
+      createdAt: { ...isoDateField },
+      updatedAt: { ...isoDateField }
+    }
+  }
+);
+var supervisionVoteSchema = defineSchema(
+  "SupervisionVote",
+  z.object({
+    id: z.string(),
+    disputeId: z.string(),
+    agent: addressSchema,
+    vote: z.nativeEnum(VoteChoice),
+    weightSnapshot: z.number(),
+    createdCycleId: z.string(),
+    createdAt: isoDateSchema
+  }),
+  {
+    type: "object",
+    additionalProperties: false,
+    required: ["id", "disputeId", "agent", "vote", "weightSnapshot", "createdCycleId", "createdAt"],
+    properties: {
+      id: { ...stringField },
+      disputeId: { ...stringField },
+      agent: { ...addressField },
+      vote: {
+        type: "string",
+        enum: Object.values(VoteChoice)
+      },
+      weightSnapshot: { ...numberField },
+      createdCycleId: { ...stringField },
+      createdAt: { ...isoDateField }
+    }
+  }
+);
+var cycleWorkloadSchema = defineSchema(
+  "CycleWorkload",
+  z.object({
+    id: z.string(),
+    cycleId: z.string(),
+    disputeId: z.string().nullable(),
+    taskId: z.string().nullable().optional(),
+    agent: addressSchema,
+    workload: z.number(),
+    createdAt: isoDateSchema,
+    settledAt: isoDateSchema.nullable()
+  }),
+  {
+    type: "object",
+    additionalProperties: false,
+    required: ["id", "cycleId", "disputeId", "agent", "workload", "createdAt", "settledAt"],
+    properties: {
+      id: { ...stringField },
+      cycleId: { ...stringField },
+      disputeId: { ...stringField, nullable: true },
+      taskId: { ...stringField, nullable: true },
+      agent: { ...addressField },
+      workload: { ...numberField },
+      createdAt: { ...isoDateField },
+      settledAt: { ...nullableIsoDateOpenApi }
+    }
+  }
+);
+var cycleSchema = defineSchema(
+  "Cycle",
+  z.object({
+    id: z.string(),
+    status: z.nativeEnum(CycleStatus),
+    mintedAmount: z.number().int(),
+    taxPool: z.number().int(),
+    penaltyPool: z.number().int(),
+    startedAt: isoDateSchema,
+    closedAt: isoDateSchema.nullable()
+  }),
+  {
+    type: "object",
+    additionalProperties: false,
+    required: ["id", "status", "mintedAmount", "taxPool", "penaltyPool", "startedAt", "closedAt"],
+    properties: {
+      id: { ...stringField },
+      status: {
+        type: "string",
+        enum: Object.values(CycleStatus)
+      },
+      mintedAmount: { ...integerField },
+      taxPool: { ...integerField },
+      penaltyPool: { ...integerField },
+      startedAt: { ...isoDateField },
+      closedAt: { ...nullableIsoDateOpenApi }
+    }
+  }
+);
+var activityEventSchema = defineSchema(
+  "ActivityEvent",
+  z.object({
+    id: z.string(),
+    type: z.nativeEnum(ActivityEventType),
+    cycleId: z.string(),
+    taskId: z.string().nullable(),
+    disputeId: z.string().nullable(),
+    actor: addressSchema,
+    createdAt: isoDateSchema
+  }),
+  {
+    type: "object",
+    additionalProperties: false,
+    required: ["id", "type", "cycleId", "taskId", "disputeId", "actor", "createdAt"],
+    properties: {
+      id: { ...stringField },
+      type: {
+        type: "string",
+        enum: Object.values(ActivityEventType)
+      },
+      cycleId: { ...stringField },
+      taskId: { ...stringField, nullable: true },
+      disputeId: { ...stringField, nullable: true },
+      actor: { ...addressField },
+      createdAt: { ...isoDateField }
+    }
+  }
+);
+var dashboardMetricSnapshotSchema = defineSchema(
+  "DashboardMetricSnapshot",
+  z.object({
+    tasksPublished: z.number().int(),
+    tasksIntented: z.number().int(),
+    tasksCompleted: z.number().int(),
+    disputesOpened: z.number().int()
+  }),
+  {
+    type: "object",
+    additionalProperties: false,
+    required: ["tasksPublished", "tasksIntented", "tasksCompleted", "disputesOpened"],
+    properties: {
+      tasksPublished: { ...integerField },
+      tasksIntented: { ...integerField },
+      tasksCompleted: { ...integerField },
+      disputesOpened: { ...integerField }
+    }
+  }
+);
+var dashboardSummaryResponseSchema = defineSchema(
+  "DashboardSummaryResponse",
+  z.object({
+    timezone: z.string(),
+    generatedAt: isoDateSchema,
+    activeCycleId: z.string(),
+    today: dashboardMetricSnapshotSchema.schema,
+    currentCycle: dashboardMetricSnapshotSchema.schema,
+    totals: z.object({
+      tasks: z.number().int(),
+      disputes: z.number().int(),
+      agents: z.number().int()
+    })
+  }),
+  {
+    type: "object",
+    additionalProperties: false,
+    required: ["timezone", "generatedAt", "activeCycleId", "today", "currentCycle", "totals"],
+    properties: {
+      timezone: { ...stringField },
+      generatedAt: { ...isoDateField },
+      activeCycleId: { ...stringField },
+      today: schemaRef(dashboardMetricSnapshotSchema),
+      currentCycle: schemaRef(dashboardMetricSnapshotSchema),
+      totals: {
+        type: "object",
+        additionalProperties: false,
+        required: ["tasks", "disputes", "agents"],
+        properties: {
+          tasks: { ...integerField },
+          disputes: { ...integerField },
+          agents: { ...integerField }
+        }
+      }
+    }
+  }
+);
+var dashboardTrendPointSchema = defineSchema(
+  "DashboardTrendPoint",
+  z.object({
+    bucketStart: isoDateSchema,
+    label: z.string(),
+    tasksPublished: z.number().int(),
+    tasksIntented: z.number().int(),
+    tasksCompleted: z.number().int(),
+    disputesOpened: z.number().int()
+  }),
+  {
+    type: "object",
+    additionalProperties: false,
+    required: [
+      "bucketStart",
+      "label",
+      "tasksPublished",
+      "tasksIntented",
+      "tasksCompleted",
+      "disputesOpened"
+    ],
+    properties: {
+      bucketStart: { ...isoDateField },
+      label: { ...stringField },
+      tasksPublished: { ...integerField },
+      tasksIntented: { ...integerField },
+      tasksCompleted: { ...integerField },
+      disputesOpened: { ...integerField }
+    }
+  }
+);
+var dashboardTrendsResponseSchema = defineSchema(
+  "DashboardTrendsResponse",
+  z.object({
+    timezone: z.string(),
+    generatedAt: isoDateSchema,
+    window: z.enum(["7d", "30d"]),
+    points: z.array(dashboardTrendPointSchema.schema)
+  }),
+  {
+    type: "object",
+    additionalProperties: false,
+    required: ["timezone", "generatedAt", "window", "points"],
+    properties: {
+      timezone: { ...stringField },
+      generatedAt: { ...isoDateField },
+      window: {
+        type: "string",
+        enum: ["7d", "30d"]
+      },
+      points: {
+        type: "array",
+        items: schemaRef(dashboardTrendPointSchema)
+      }
+    }
+  }
+);
+var agentDirectoryItemSchema = defineSchema(
+  "AgentDirectoryItem",
+  z.object({
+    address: addressSchema,
+    name: z.string(),
+    bio: z.string(),
+    reputation: reputationTripleSchema.schema,
+    stats: agentStatsSchema.schema,
+    createdAt: isoDateSchema,
+    updatedAt: isoDateSchema,
+    latestActivityAt: isoDateSchema.nullable(),
+    score: z.number(),
+    isActive: z.boolean()
+  }),
+  {
+    type: "object",
+    additionalProperties: false,
+    required: [
+      "address",
+      "name",
+      "bio",
+      "reputation",
+      "stats",
+      "createdAt",
+      "updatedAt",
+      "latestActivityAt",
+      "score",
+      "isActive"
+    ],
+    properties: {
+      address: { ...addressField },
+      name: { ...stringField },
+      bio: { ...stringField },
+      reputation: schemaRef(reputationTripleSchema),
+      stats: schemaRef(agentStatsSchema),
+      createdAt: { ...isoDateField },
+      updatedAt: { ...isoDateField },
+      latestActivityAt: { ...nullableIsoDateOpenApi },
+      score: { ...numberField },
+      isActive: { ...boolField }
+    }
+  }
+);
+var paginatedResponseOpenApi = (itemSchema) => ({
+  type: "object",
+  additionalProperties: false,
+  required: ["items", "nextCursor"],
+  properties: {
+    items: {
+      type: "array",
+      items: schemaRef(itemSchema)
+    },
+    nextCursor: {
+      ...stringField,
+      nullable: true
+    }
+  }
+});
+var definePaginatedResponseSchema = (name, itemSchema) => defineSchema(
+  name,
+  z.object({
+    items: z.array(itemSchema.schema),
+    nextCursor: z.string().nullable()
+  }),
+  paginatedResponseOpenApi(itemSchema)
+);
+var paginatedTaskResponseSchema = definePaginatedResponseSchema("PaginatedTaskResponse", taskSchema);
+var paginatedTaskIntentionResponseSchema = definePaginatedResponseSchema(
+  "PaginatedTaskIntentionResponse",
+  taskIntentionSchema
+);
+var paginatedSubmissionResponseSchema = definePaginatedResponseSchema(
+  "PaginatedSubmissionResponse",
+  submissionSchema
+);
+var paginatedDisputeResponseSchema = definePaginatedResponseSchema(
+  "PaginatedDisputeResponse",
+  disputeSchema
+);
+var paginatedAgentDirectoryResponseSchema = definePaginatedResponseSchema(
+  "PaginatedAgentDirectoryResponse",
+  agentDirectoryItemSchema
+);
+var paginatedActivityResponseSchema = definePaginatedResponseSchema(
+  "PaginatedActivityResponse",
+  activityEventSchema
+);
+var paginatedCycleResponseSchema = definePaginatedResponseSchema("PaginatedCycleResponse", cycleSchema);
+var ledgerBalanceSchema = defineSchema(
+  "LedgerBalance",
+  z.object({
+    address: addressSchema,
+    available: z.number().int(),
+    updatedAt: isoDateSchema
+  }),
+  {
+    type: "object",
+    additionalProperties: false,
+    required: ["address", "available", "updatedAt"],
+    properties: {
+      address: { ...addressField },
+      available: { ...integerField },
+      updatedAt: { ...isoDateField }
+    }
+  }
+);
+var healthStatusSchema = defineSchema(
+  "HealthStatus",
+  z.object({
+    ok: z.boolean(),
+    service: z.string()
+  }),
+  {
+    type: "object",
+    additionalProperties: false,
+    required: ["ok", "service"],
+    properties: {
+      ok: { ...boolField },
+      service: { ...stringField }
+    }
+  }
+);
+var latencySummarySchema = defineSchema(
+  "LatencySummary",
+  z.object({
+    count: z.number().int(),
+    avgMs: z.number(),
+    p50Ms: z.number(),
+    p95Ms: z.number(),
+    p99Ms: z.number(),
+    maxMs: z.number()
+  }),
+  {
+    type: "object",
+    additionalProperties: false,
+    required: ["count", "avgMs", "p50Ms", "p95Ms", "p99Ms", "maxMs"],
+    properties: {
+      count: { ...integerField },
+      avgMs: { ...numberField },
+      p50Ms: { ...numberField },
+      p95Ms: { ...numberField },
+      p99Ms: { ...numberField },
+      maxMs: { ...numberField }
+    }
+  }
+);
+var serviceMetricsResponseSchema = defineSchema(
+  "ServiceMetricsResponse",
+  z.object({
+    generatedAt: isoDateSchema,
+    startedAt: isoDateSchema,
+    counters: z.object({
+      requestsTotal: z.number().int(),
+      errorsTotal: z.number().int(),
+      rateLimitedTotal: z.number().int(),
+      writeTotal: z.number().int(),
+      writeErrorTotal: z.number().int(),
+      writeConflictTotal: z.number().int(),
+      writeDeadlockTotal: z.number().int()
+    }),
+    latencies: z.object({
+      requests: latencySummarySchema.schema,
+      writes: latencySummarySchema.schema
+    })
+  }),
+  {
+    type: "object",
+    additionalProperties: false,
+    required: ["generatedAt", "startedAt", "counters", "latencies"],
+    properties: {
+      generatedAt: { ...isoDateField },
+      startedAt: { ...isoDateField },
+      counters: {
+        type: "object",
+        additionalProperties: false,
+        required: [
+          "requestsTotal",
+          "errorsTotal",
+          "rateLimitedTotal",
+          "writeTotal",
+          "writeErrorTotal",
+          "writeConflictTotal",
+          "writeDeadlockTotal"
+        ],
+        properties: {
+          requestsTotal: { ...integerField },
+          errorsTotal: { ...integerField },
+          rateLimitedTotal: { ...integerField },
+          writeTotal: { ...integerField },
+          writeErrorTotal: { ...integerField },
+          writeConflictTotal: { ...integerField },
+          writeDeadlockTotal: { ...integerField }
+        }
+      },
+      latencies: {
+        type: "object",
+        additionalProperties: false,
+        required: ["requests", "writes"],
+        properties: {
+          requests: schemaRef(latencySummarySchema),
+          writes: schemaRef(latencySummarySchema)
+        }
+      }
+    }
+  }
+);
+var authChallengeRequestSchema = defineSchema(
+  "AuthChallengeRequest",
+  z.object({
+    address: addressSchema
+  }),
+  {
+    type: "object",
+    additionalProperties: false,
+    required: ["address"],
+    properties: {
+      address: { ...addressField }
+    }
+  }
+);
+var authChallengeResponseSchema = defineSchema(
+  "AuthChallengeResponse",
+  z.object({
+    nonce: z.string(),
+    message: z.string()
+  }),
+  {
+    type: "object",
+    additionalProperties: false,
+    required: ["nonce", "message"],
+    properties: {
+      nonce: { ...stringField },
+      message: { ...stringField }
+    }
+  }
+);
+var authVerifyRequestSchema = defineSchema(
+  "AuthVerifyRequest",
+  z.object({
+    address: addressSchema,
+    nonce: nonEmptyStringSchema,
+    message: nonEmptyStringSchema,
+    signature: nonEmptyStringSchema
+  }),
+  {
+    type: "object",
+    additionalProperties: false,
+    required: ["address", "nonce", "message", "signature"],
+    properties: {
+      address: { ...addressField },
+      nonce: { ...nonEmptyStringField },
+      message: { ...nonEmptyStringField },
+      signature: { ...nonEmptyStringField }
+    }
+  }
+);
+var authVerifyResponseSchema = defineSchema(
+  "AuthVerifyResponse",
+  z.object({
+    token: z.string(),
+    expiresIn: z.string()
+  }),
+  {
+    type: "object",
+    additionalProperties: false,
+    required: ["token", "expiresIn"],
+    properties: {
+      token: { ...stringField },
+      expiresIn: { ...stringField }
+    }
+  }
+);
+var voteDisputeResultSchema = defineSchema(
+  "VoteDisputeResult",
+  z.object({
+    vote: supervisionVoteSchema.schema,
+    workload: cycleWorkloadSchema.schema
+  }),
+  {
+    type: "object",
+    additionalProperties: false,
+    required: ["vote", "workload"],
+    properties: {
+      vote: schemaRef(supervisionVoteSchema),
+      workload: schemaRef(cycleWorkloadSchema)
+    }
+  }
+);
+var cycleDistributionSchema = defineSchema(
+  "CycleDistribution",
+  z.object({
+    agent: addressSchema,
+    amount: z.number().int()
+  }),
+  {
+    type: "object",
+    additionalProperties: false,
+    required: ["agent", "amount"],
+    properties: {
+      agent: { ...addressField },
+      amount: { ...integerField }
+    }
+  }
+);
+var closeCycleResultSchema = defineSchema(
+  "CloseCycleResult",
+  z.object({
+    closedCycleId: z.string(),
+    openedCycleId: z.string(),
+    rewardPool: z.number().int(),
+    distributions: z.array(cycleDistributionSchema.schema),
+    finalizedDisputes: z.array(z.string())
+  }),
+  {
+    type: "object",
+    additionalProperties: false,
+    required: ["closedCycleId", "openedCycleId", "rewardPool", "distributions", "finalizedDisputes"],
+    properties: {
+      closedCycleId: { ...stringField },
+      openedCycleId: { ...stringField },
+      rewardPool: { ...integerField },
+      distributions: {
+        type: "array",
+        items: schemaRef(cycleDistributionSchema)
+      },
+      finalizedDisputes: {
+        type: "array",
+        items: { ...stringField }
+      }
+    }
+  }
+);
+var cycleRewardsResponseSchema = defineSchema(
+  "CycleRewardsResponse",
+  z.object({
+    cycle: cycleSchema.schema,
+    rewardPool: z.number().int(),
+    distributions: z.array(cycleDistributionSchema.schema),
+    workloads: z.array(cycleWorkloadSchema.schema)
+  }),
+  {
+    type: "object",
+    additionalProperties: false,
+    required: ["cycle", "rewardPool", "distributions", "workloads"],
+    properties: {
+      cycle: schemaRef(cycleSchema),
+      rewardPool: { ...integerField },
+      distributions: {
+        type: "array",
+        items: schemaRef(cycleDistributionSchema)
+      },
+      workloads: {
+        type: "array",
+        items: schemaRef(cycleWorkloadSchema)
+      }
+    }
+  }
+);
+var bridgeExportItemSchema = defineSchema(
+  "BridgeExportItem",
+  z.object({
+    address: addressSchema,
+    amount: z.number().int()
+  }),
+  {
+    type: "object",
+    additionalProperties: false,
+    required: ["address", "amount"],
+    properties: {
+      address: { ...addressField },
+      amount: { ...integerField }
+    }
+  }
+);
+var bridgeExportResponseSchema = defineSchema(
+  "BridgeExportResponse",
+  z.object({
+    chain: z.string(),
+    mode: z.literal("OFFCHAIN_EXPORT_ONLY"),
+    exports: z.array(bridgeExportItemSchema.schema)
+  }),
+  {
+    type: "object",
+    additionalProperties: false,
+    required: ["chain", "mode", "exports"],
+    properties: {
+      chain: { ...stringField },
+      mode: {
+        type: "string",
+        enum: ["OFFCHAIN_EXPORT_ONLY"]
+      },
+      exports: {
+        type: "array",
+        items: schemaRef(bridgeExportItemSchema)
+      }
+    }
+  }
+);
+var publicEconomyParamsSchema = defineSchema(
+  "PublicEconomyParams",
+  z.object({
+    appName: z.string(),
+    enablePersistence: z.boolean(),
+    enableRedisRateLimit: z.boolean(),
+    authChallengeTtlMinutes: z.number().int(),
+    rateLimitPerMinute: z.number().int(),
+    rateLimitBurst: z.number().int(),
+    taskTitleMaxLength: z.number().int(),
+    taskDescriptionMaxLength: z.number().int(),
+    taskAcceptanceCriteriaMaxLength: z.number().int(),
+    taskSubmissionPayloadMaxLength: z.number().int(),
+    taskSubmissionAttachmentMaxCount: z.number().int(),
+    taskSubmissionAttachmentNameMaxLength: z.number().int(),
+    taskSubmissionAttachmentUrlMaxLength: z.number().int(),
+    taskSubmissionAttachmentMaxSizeBytes: z.number().int(),
+    disputeReasonMaxLength: z.number().int(),
+    taskSlotsMax: z.number().int(),
+    taskRewardPerSlotMax: z.number().int(),
+    taskDeadlineMaxHours: z.number().int(),
+    taxRateBps: z.number().int(),
+    taxMin: z.number().int(),
+    rewardMin: z.number().int(),
+    initialAgentBalance: z.number().int(),
+    mintPerCycle: z.number().int(),
+    terminationPenaltyBps: z.number().int(),
+    submissionTimeoutHours: z.number().int(),
+    resubmitCooldownMinutes: z.number().int(),
+    disputeQuorum: z.number().int(),
+    disputeApprovalBps: z.number().int(),
+    reputationWeightPublisherBps: z.number().int(),
+    reputationWeightWorkerBps: z.number().int(),
+    reputationWeightSupervisorBps: z.number().int(),
+    scoreWeightReputationBps: z.number().int(),
+    scoreWeightCompletionBps: z.number().int(),
+    scoreWeightQualityBps: z.number().int(),
+    bridgeChain: z.string(),
+    bridgeMode: z.literal("OFFCHAIN_EXPORT_ONLY")
+  }),
+  {
+    type: "object",
+    additionalProperties: false,
+    required: [
+      "appName",
+      "enablePersistence",
+      "enableRedisRateLimit",
+      "authChallengeTtlMinutes",
+      "rateLimitPerMinute",
+      "rateLimitBurst",
+      "taskTitleMaxLength",
+      "taskDescriptionMaxLength",
+      "taskAcceptanceCriteriaMaxLength",
+      "taskSubmissionPayloadMaxLength",
+      "taskSubmissionAttachmentMaxCount",
+      "taskSubmissionAttachmentNameMaxLength",
+      "taskSubmissionAttachmentUrlMaxLength",
+      "taskSubmissionAttachmentMaxSizeBytes",
+      "disputeReasonMaxLength",
+      "taskSlotsMax",
+      "taskRewardPerSlotMax",
+      "taskDeadlineMaxHours",
+      "taxRateBps",
+      "taxMin",
+      "rewardMin",
+      "initialAgentBalance",
+      "mintPerCycle",
+      "terminationPenaltyBps",
+      "submissionTimeoutHours",
+      "resubmitCooldownMinutes",
+      "disputeQuorum",
+      "disputeApprovalBps",
+      "reputationWeightPublisherBps",
+      "reputationWeightWorkerBps",
+      "reputationWeightSupervisorBps",
+      "scoreWeightReputationBps",
+      "scoreWeightCompletionBps",
+      "scoreWeightQualityBps",
+      "bridgeChain",
+      "bridgeMode"
+    ],
+    properties: {
+      appName: { ...stringField },
+      enablePersistence: { ...boolField },
+      enableRedisRateLimit: { ...boolField },
+      authChallengeTtlMinutes: { ...integerField },
+      rateLimitPerMinute: { ...integerField },
+      rateLimitBurst: { ...integerField },
+      taskTitleMaxLength: { ...integerField },
+      taskDescriptionMaxLength: { ...integerField },
+      taskAcceptanceCriteriaMaxLength: { ...integerField },
+      taskSubmissionPayloadMaxLength: { ...integerField },
+      taskSubmissionAttachmentMaxCount: { ...integerField },
+      taskSubmissionAttachmentNameMaxLength: { ...integerField },
+      taskSubmissionAttachmentUrlMaxLength: { ...integerField },
+      taskSubmissionAttachmentMaxSizeBytes: { ...integerField },
+      disputeReasonMaxLength: { ...integerField },
+      taskSlotsMax: { ...integerField },
+      taskRewardPerSlotMax: { ...integerField },
+      taskDeadlineMaxHours: { ...integerField },
+      taxRateBps: { ...integerField },
+      taxMin: { ...integerField },
+      rewardMin: { ...integerField },
+      initialAgentBalance: { ...integerField },
+      mintPerCycle: { ...integerField },
+      terminationPenaltyBps: { ...integerField },
+      submissionTimeoutHours: { ...integerField },
+      resubmitCooldownMinutes: { ...integerField },
+      disputeQuorum: { ...integerField },
+      disputeApprovalBps: { ...integerField },
+      reputationWeightPublisherBps: { ...integerField },
+      reputationWeightWorkerBps: { ...integerField },
+      reputationWeightSupervisorBps: { ...integerField },
+      scoreWeightReputationBps: { ...integerField },
+      scoreWeightCompletionBps: { ...integerField },
+      scoreWeightQualityBps: { ...integerField },
+      bridgeChain: { ...stringField },
+      bridgeMode: {
+        type: "string",
+        enum: ["OFFCHAIN_EXPORT_ONLY"]
+      }
+    }
+  }
+);
+var createTaskRequestSchema = defineSchema(
+  "CreateTaskRequest",
+  z.object({
+    title: nonEmptyStringSchema,
+    descriptionMd: nonEmptyStringSchema,
+    acceptanceCriteria: nonEmptyStringSchema,
+    deadlineUtc: isoDateSchema,
+    displayTimezone: nonEmptyStringSchema,
+    slotsTotal: z.number().int().positive(),
+    rewardPerSlot: z.number().int().positive(),
+    allowRepeatCompletionsBySameAgent: z.boolean()
+  }),
+  {
+    type: "object",
+    additionalProperties: false,
+    required: [
+      "title",
+      "descriptionMd",
+      "acceptanceCriteria",
+      "deadlineUtc",
+      "displayTimezone",
+      "slotsTotal",
+      "rewardPerSlot",
+      "allowRepeatCompletionsBySameAgent"
+    ],
+    properties: {
+      title: { ...nonEmptyStringField },
+      descriptionMd: { ...nonEmptyStringField },
+      acceptanceCriteria: { ...nonEmptyStringField },
+      deadlineUtc: { ...isoDateField },
+      displayTimezone: { ...nonEmptyStringField },
+      slotsTotal: { ...integerField, minimum: 1 },
+      rewardPerSlot: { ...integerField, minimum: 1 },
+      allowRepeatCompletionsBySameAgent: { ...boolField }
+    }
+  }
+);
+var submitTaskRequestSchema = defineSchema(
+  "SubmitTaskRequest",
+  z.object({
+    payloadMd: nonEmptyStringSchema,
+    attachments: z.array(submissionAttachmentSchema.schema).optional()
+  }),
+  {
+    type: "object",
+    additionalProperties: false,
+    required: ["payloadMd"],
+    properties: {
+      payloadMd: { ...nonEmptyStringField },
+      attachments: {
+        type: "array",
+        items: schemaRef(submissionAttachmentSchema)
+      }
+    }
+  }
+);
+var openDisputeRequestSchema = defineSchema(
+  "OpenDisputeRequest",
+  z.object({
+    taskId: nonEmptyStringSchema,
+    submissionId: nonEmptyStringSchema,
+    reasonMd: nonEmptyStringSchema
+  }),
+  {
+    type: "object",
+    additionalProperties: false,
+    required: ["taskId", "submissionId", "reasonMd"],
+    properties: {
+      taskId: { ...nonEmptyStringField },
+      submissionId: { ...nonEmptyStringField },
+      reasonMd: { ...nonEmptyStringField }
+    }
+  }
+);
+var voteDisputeRequestSchema = defineSchema(
+  "VoteDisputeRequest",
+  z.object({
+    vote: z.nativeEnum(VoteChoice)
+  }),
+  {
+    type: "object",
+    additionalProperties: false,
+    required: ["vote"],
+    properties: {
+      vote: {
+        type: "string",
+        enum: Object.values(VoteChoice)
+      }
+    }
+  }
+);
+var updateAgentProfileRequestSchema = defineSchema(
+  "UpdateAgentProfileRequest",
+  z.object({
+    name: z.string().max(120).optional(),
+    bio: z.string().max(1e3).optional()
+  }),
+  {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+      name: { ...stringField, maxLength: 120 },
+      bio: { ...stringField, maxLength: 1e3 }
+    }
+  }
+);
+var overrideDisputeRequestSchema = defineSchema(
+  "OverrideDisputeRequest",
+  z.object({
+    result: z.enum(["COMPLETED", "NOT_COMPLETED"])
+  }),
+  {
+    type: "object",
+    additionalProperties: false,
+    required: ["result"],
+    properties: {
+      result: {
+        type: "string",
+        enum: ["COMPLETED", "NOT_COMPLETED"]
+      }
+    }
+  }
+);
+var bridgeExportRequestSchema = defineSchema(
+  "BridgeExportRequest",
+  z.object({
+    addresses: z.array(addressSchema).optional()
+  }),
+  {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+      addresses: { ...addressArrayOpenApi }
+    }
+  }
+);
+var v2ApiErrorEnvelopeSchema = defineSchema(
+  "V2ApiErrorEnvelope",
+  z.object({
+    error: z.object({
+      code: z.string(),
+      message: z.string(),
+      details: z.unknown().optional(),
+      requestId: z.string(),
+      retryable: z.boolean()
+    })
+  }),
+  {
+    type: "object",
+    additionalProperties: false,
+    required: ["error"],
+    properties: {
+      error: {
+        type: "object",
+        additionalProperties: false,
+        required: ["code", "message", "requestId", "retryable"],
+        properties: {
+          code: { ...stringField },
+          message: { ...stringField },
+          details: {},
+          requestId: { ...stringField },
+          retryable: { ...boolField }
+        }
+      }
+    }
+  }
+);
+var booleanQuerySchema = z.union([z.boolean(), z.enum(["true", "false"]).transform((value) => value === "true")]).optional();
+var taskListQuerySchemaV2 = z.object({
+  q: nonEmptyStringSchema.optional(),
+  status: z.nativeEnum(TaskStatus).optional(),
+  publisher: z.string().optional(),
+  sort: z.enum(["latest", "created", "deadline", "reward"]).default("latest"),
+  order: z.enum(["asc", "desc"]).default("desc"),
+  cursor: z.string().optional(),
+  limit: z.coerce.number().int().min(1).max(100).default(20)
+});
+var taskIntentionListQuerySchemaV2 = z.object({
+  cursor: z.string().optional(),
+  limit: z.coerce.number().int().min(1).max(100).default(20)
+});
+var submissionListQuerySchemaV2 = z.object({
+  taskId: z.string().optional(),
+  agent: z.string().optional(),
+  status: z.nativeEnum(SubmissionStatus).optional(),
+  q: nonEmptyStringSchema.optional(),
+  sort: z.enum(["latest", "created"]).default("latest"),
+  order: z.enum(["asc", "desc"]).default("desc"),
+  cursor: z.string().optional(),
+  limit: z.coerce.number().int().min(1).max(100).default(20)
+});
+var disputeListQuerySchemaV2 = z.object({
+  taskId: z.string().optional(),
+  opener: z.string().optional(),
+  status: z.nativeEnum(DisputeStatus).optional(),
+  q: nonEmptyStringSchema.optional(),
+  sort: z.enum(["latest", "created"]).default("latest"),
+  order: z.enum(["asc", "desc"]).default("desc"),
+  cursor: z.string().optional(),
+  limit: z.coerce.number().int().min(1).max(100).default(20)
+});
+var activityListQuerySchemaV2 = z.object({
+  taskId: z.string().optional(),
+  disputeId: z.string().optional(),
+  address: z.string().optional(),
+  type: z.nativeEnum(ActivityEventType).optional(),
+  order: z.enum(["asc", "desc"]).default("desc"),
+  cursor: z.string().optional(),
+  limit: z.coerce.number().int().min(1).max(100).default(20)
+});
+var agentListQuerySchemaV2 = z.object({
+  q: nonEmptyStringSchema.optional(),
+  activeOnly: booleanQuerySchema.transform((value) => value ?? false),
+  sort: z.enum(["latest", "score", "reputation", "completed", "published", "intented"]).default("latest"),
+  order: z.enum(["asc", "desc"]).default("desc"),
+  cursor: z.string().optional(),
+  limit: z.coerce.number().int().min(1).max(100).default(20)
+});
+var dashboardSummaryQuerySchema = z.object({
+  tz: nonEmptyStringSchema.default("UTC")
+});
+var dashboardTrendsQuerySchema = z.object({
+  tz: nonEmptyStringSchema.default("UTC"),
+  window: z.enum(["7d", "30d"]).default("7d")
+});
+var cycleListQuerySchemaV2 = z.object({
+  cursor: z.string().optional(),
+  limit: z.coerce.number().int().min(1).max(100).default(20)
+});
+var idPathSchema = z.object({
+  id: nonEmptyStringSchema
+});
+var addressPathSchema = z.object({
+  address: addressSchema
+});
+var emptyObjectSchema = z.object({});
+var namedSchemas = [
+  reputationTripleSchema,
+  agentStatsSchema,
+  agentProfileSchema,
+  taskSchema,
+  taskIntentionSchema,
+  submissionAttachmentSchema,
+  submissionSchema,
+  disputeSchema,
+  supervisionVoteSchema,
+  cycleWorkloadSchema,
+  cycleSchema,
+  activityEventSchema,
+  dashboardMetricSnapshotSchema,
+  dashboardSummaryResponseSchema,
+  dashboardTrendPointSchema,
+  dashboardTrendsResponseSchema,
+  agentDirectoryItemSchema,
+  paginatedTaskResponseSchema,
+  paginatedTaskIntentionResponseSchema,
+  paginatedSubmissionResponseSchema,
+  paginatedDisputeResponseSchema,
+  paginatedAgentDirectoryResponseSchema,
+  paginatedActivityResponseSchema,
+  paginatedCycleResponseSchema,
+  ledgerBalanceSchema,
+  healthStatusSchema,
+  latencySummarySchema,
+  serviceMetricsResponseSchema,
+  authChallengeRequestSchema,
+  authChallengeResponseSchema,
+  authVerifyRequestSchema,
+  authVerifyResponseSchema,
+  voteDisputeResultSchema,
+  cycleDistributionSchema,
+  closeCycleResultSchema,
+  cycleRewardsResponseSchema,
+  bridgeExportItemSchema,
+  bridgeExportResponseSchema,
+  publicEconomyParamsSchema,
+  createTaskRequestSchema,
+  submitTaskRequestSchema,
+  openDisputeRequestSchema,
+  voteDisputeRequestSchema,
+  updateAgentProfileRequestSchema,
+  overrideDisputeRequestSchema,
+  bridgeExportRequestSchema,
+  v2ApiErrorEnvelopeSchema
+];
+var openApiSchemaComponents = Object.fromEntries(
+  namedSchemas.map((item) => [item.name, item.openapi])
+);
+
+// ../../packages/contracts/src/operations.ts
+var apiParameter = (input) => input;
+var queryStringParam = (name, schema, description, required = false) => apiParameter({
+  in: "query",
+  name,
+  required,
+  description,
+  schema
+});
+var pathStringParam = (name, description, schema = { type: "string", minLength: 1 }) => apiParameter({
+  in: "path",
+  name,
+  required: true,
+  description,
+  schema
+});
+var queryCursorParam = queryStringParam(
+  "cursor",
+  { type: "string" },
+  { en: "Opaque pagination cursor", zh: "\u5206\u9875\u6E38\u6807" }
+);
+var queryLimitParam = queryStringParam(
+  "limit",
+  { type: "integer", minimum: 1, maximum: 100 },
+  { en: "Page size", zh: "\u5206\u9875\u5927\u5C0F" }
+);
+var defineOperation = (operation) => operation;
+var defineOperationSpec = (spec) => defineOperation({
+  operationId: `${spec.baseOperationId}V2`,
+  version: "v2",
+  method: spec.method,
+  pathTemplate: spec.pathTemplate,
+  tag: spec.tag,
+  auth: spec.auth,
+  summary: spec.summary,
+  description: spec.description,
+  pathParamsSchema: spec.pathParamsSchema,
+  querySchema: spec.querySchema,
+  bodySchema: spec.bodySchema,
+  responseSchema: spec.responseSchema,
+  responseComponent: spec.responseComponent,
+  requestBodyComponent: spec.requestBodyComponent,
+  parameters: spec.parameters,
+  errorStatuses: spec.errorStatuses
+});
+var taskListParameters = [
+  queryStringParam(
+    "q",
+    { type: "string", minLength: 1 },
+    { en: "Search by id, title, description, criteria, or publisher", zh: "\u6309 id\u3001\u6807\u9898\u3001\u63CF\u8FF0\u3001\u9A8C\u6536\u6807\u51C6\u6216\u53D1\u5E03\u8005\u641C\u7D22" }
+  ),
+  queryStringParam(
+    "status",
+    { type: "string", enum: ["OPEN", "IN_PROGRESS", "TERMINATED", "CLOSED"] },
+    { en: "Task status filter", zh: "\u4EFB\u52A1\u72B6\u6001\u7B5B\u9009" }
+  ),
+  queryStringParam("publisher", { type: "string", pattern: "^0x[a-fA-F0-9]{40}$" }, { en: "Publisher address", zh: "\u53D1\u5E03\u8005\u5730\u5740" }),
+  queryStringParam(
+    "sort",
+    { type: "string", enum: ["latest", "created", "deadline", "reward"] },
+    { en: "Sort key", zh: "\u6392\u5E8F\u5B57\u6BB5" }
+  ),
+  queryStringParam(
+    "order",
+    { type: "string", enum: ["asc", "desc"] },
+    { en: "Sort order", zh: "\u6392\u5E8F\u65B9\u5411" }
+  ),
+  queryCursorParam,
+  queryLimitParam
+];
+var disputeListParameters = [
+  queryStringParam("taskId", { type: "string" }, { en: "Task id", zh: "\u4EFB\u52A1 id" }),
+  queryStringParam("opener", { type: "string", pattern: "^0x[a-fA-F0-9]{40}$" }, { en: "Dispute opener address", zh: "\u53D1\u8D77\u65B9\u5730\u5740" }),
+  queryStringParam(
+    "status",
+    { type: "string", enum: ["OPEN", "RESOLVED_COMPLETED"] },
+    { en: "Dispute status filter", zh: "\u4E89\u8BAE\u72B6\u6001\u7B5B\u9009" }
+  ),
+  queryStringParam(
+    "q",
+    { type: "string", minLength: 1 },
+    { en: "Search by ids, opener, or dispute reason", zh: "\u6309 id\u3001\u53D1\u8D77\u65B9\u6216\u4E89\u8BAE\u539F\u56E0\u641C\u7D22" }
+  ),
+  queryStringParam("sort", { type: "string", enum: ["latest", "created"] }, { en: "Sort key", zh: "\u6392\u5E8F\u5B57\u6BB5" }),
+  queryStringParam("order", { type: "string", enum: ["asc", "desc"] }, { en: "Sort order", zh: "\u6392\u5E8F\u65B9\u5411" }),
+  queryCursorParam,
+  queryLimitParam
+];
+var activityListParameters = [
+  queryStringParam("taskId", { type: "string" }, { en: "Task id filter", zh: "\u4EFB\u52A1 id \u7B5B\u9009" }),
+  queryStringParam("disputeId", { type: "string" }, { en: "Dispute id filter", zh: "\u4E89\u8BAE id \u7B5B\u9009" }),
+  queryStringParam("address", { type: "string", pattern: "^0x[a-fA-F0-9]{40}$" }, { en: "Actor address filter", zh: "\u884C\u4E3A\u5730\u5740\u7B5B\u9009" }),
+  queryStringParam(
+    "type",
+    {
+      type: "string",
+      enum: [
+        "TASK_PUBLISHED",
+        "TASK_INTENDED",
+        "TASK_SUBMITTED",
+        "SUBMISSION_REJECTED",
+        "TASK_COMPLETED",
+        "DISPUTE_OPENED",
+        "TASK_TERMINATED"
+      ]
+    },
+    { en: "Event type filter", zh: "\u4E8B\u4EF6\u7C7B\u578B\u7B5B\u9009" }
+  ),
+  queryStringParam("order", { type: "string", enum: ["asc", "desc"] }, { en: "Sort order", zh: "\u6392\u5E8F\u65B9\u5411" }),
+  queryCursorParam,
+  queryLimitParam
+];
+var agentListParameters = [
+  queryStringParam("q", { type: "string", minLength: 1 }, { en: "Search by address, name, or bio", zh: "\u6309\u5730\u5740\u3001\u540D\u79F0\u6216\u7B80\u4ECB\u641C\u7D22" }),
+  queryStringParam("activeOnly", { type: "boolean" }, { en: "Only return active agents", zh: "\u4EC5\u8FD4\u56DE\u6D3B\u8DC3 Agent" }),
+  queryStringParam(
+    "sort",
+    { type: "string", enum: ["latest", "score", "reputation", "completed", "published", "intented"] },
+    { en: "Sort key", zh: "\u6392\u5E8F\u5B57\u6BB5" }
+  ),
+  queryStringParam("order", { type: "string", enum: ["asc", "desc"] }, { en: "Sort order", zh: "\u6392\u5E8F\u65B9\u5411" }),
+  queryCursorParam,
+  queryLimitParam
+];
+var taskIntentionListParameters = [queryCursorParam, queryLimitParam];
+var submissionListParameters = [
+  queryStringParam("taskId", { type: "string" }, { en: "Task id filter", zh: "\u4EFB\u52A1 id \u7B5B\u9009" }),
+  queryStringParam(
+    "agent",
+    { type: "string", pattern: "^0x[a-fA-F0-9]{40}$" },
+    { en: "Submission agent address", zh: "\u63D0\u4EA4\u65B9\u5730\u5740" }
+  ),
+  queryStringParam(
+    "status",
+    { type: "string", enum: ["SUBMITTED", "CONFIRMED", "REJECTED"] },
+    { en: "Submission status filter", zh: "\u63D0\u4EA4\u72B6\u6001\u7B5B\u9009" }
+  ),
+  queryStringParam(
+    "q",
+    { type: "string", minLength: 1 },
+    { en: "Search by ids, agent, or payload", zh: "\u6309 id\u3001\u63D0\u4EA4\u8005\u6216\u63D0\u4EA4\u5185\u5BB9\u641C\u7D22" }
+  ),
+  queryStringParam("sort", { type: "string", enum: ["latest", "created"] }, { en: "Sort key", zh: "\u6392\u5E8F\u5B57\u6BB5" }),
+  queryStringParam("order", { type: "string", enum: ["asc", "desc"] }, { en: "Sort order", zh: "\u6392\u5E8F\u65B9\u5411" }),
+  queryCursorParam,
+  queryLimitParam
+];
+var dashboardSummaryParameters = [
+  queryStringParam("tz", { type: "string", default: "UTC" }, { en: "IANA timezone", zh: "IANA \u65F6\u533A" })
+];
+var dashboardTrendParameters = [
+  queryStringParam("tz", { type: "string", default: "UTC" }, { en: "IANA timezone", zh: "IANA \u65F6\u533A" }),
+  queryStringParam("window", { type: "string", enum: ["7d", "30d"], default: "7d" }, { en: "Trend window", zh: "\u8D8B\u52BF\u7A97\u53E3" })
+];
+var cycleListParametersV2 = [queryCursorParam, queryLimitParam];
+var apiOperations = [
+  defineOperationSpec({
+    baseOperationId: "systemHealth",
+    method: "GET",
+    tag: "System",
+    auth: "none",
+    summary: { en: "Health check", zh: "\u5065\u5EB7\u68C0\u67E5" },
+    pathTemplate: "/v2/system/health",
+    responseSchema: healthStatusSchema.schema,
+    responseComponent: healthStatusSchema,
+    errorStatuses: [500]
+  }),
+  defineOperationSpec({
+    baseOperationId: "systemMetrics",
+    method: "GET",
+    tag: "System",
+    auth: "admin",
+    summary: { en: "Get service metrics", zh: "\u8BFB\u53D6\u670D\u52A1\u6307\u6807" },
+    pathTemplate: "/v2/system/metrics",
+    responseSchema: serviceMetricsResponseSchema.schema,
+    responseComponent: serviceMetricsResponseSchema,
+    errorStatuses: [401, 500]
+  }),
+  defineOperationSpec({
+    baseOperationId: "authChallenge",
+    method: "POST",
+    tag: "Auth",
+    auth: "none",
+    summary: { en: "Create SIWE challenge", zh: "\u521B\u5EFA SIWE challenge" },
+    pathTemplate: "/v2/auth/challenge",
+    bodySchema: authChallengeRequestSchema.schema,
+    requestBodyComponent: authChallengeRequestSchema,
+    responseSchema: authChallengeResponseSchema.schema,
+    responseComponent: authChallengeResponseSchema,
+    errorStatuses: [400, 500]
+  }),
+  defineOperationSpec({
+    baseOperationId: "authVerify",
+    method: "POST",
+    tag: "Auth",
+    auth: "none",
+    summary: { en: "Verify SIWE signature", zh: "\u9A8C\u8BC1 SIWE \u7B7E\u540D" },
+    pathTemplate: "/v2/auth/verify",
+    bodySchema: authVerifyRequestSchema.schema,
+    requestBodyComponent: authVerifyRequestSchema,
+    responseSchema: authVerifyResponseSchema.schema,
+    responseComponent: authVerifyResponseSchema,
+    errorStatuses: [400, 401, 500]
+  }),
+  defineOperationSpec({
+    baseOperationId: "tasksList",
+    method: "GET",
+    tag: "Tasks",
+    auth: "none",
+    summary: { en: "List tasks", zh: "\u67E5\u8BE2\u4EFB\u52A1\u5217\u8868" },
+    pathTemplate: "/v2/tasks",
+    querySchema: taskListQuerySchemaV2,
+    responseSchema: paginatedTaskResponseSchema.schema,
+    responseComponent: paginatedTaskResponseSchema,
+    parameters: taskListParameters,
+    errorStatuses: [400, 500]
+  }),
+  defineOperationSpec({
+    baseOperationId: "tasksGet",
+    method: "GET",
+    tag: "Tasks",
+    auth: "none",
+    summary: { en: "Get task", zh: "\u8BFB\u53D6\u4EFB\u52A1\u8BE6\u60C5" },
+    pathTemplate: "/v2/tasks/{id}",
+    pathParamsSchema: idPathSchema,
+    responseSchema: taskSchema.schema,
+    responseComponent: taskSchema,
+    parameters: [pathStringParam("id", { en: "Task id", zh: "\u4EFB\u52A1 id" })],
+    errorStatuses: [404, 500]
+  }),
+  defineOperationSpec({
+    baseOperationId: "tasksListIntentions",
+    method: "GET",
+    tag: "Tasks",
+    auth: "none",
+    summary: { en: "List task intentions", zh: "\u67E5\u8BE2\u4EFB\u52A1\u610F\u5411\u540D\u5355" },
+    pathTemplate: "/v2/tasks/{id}/intentions",
+    pathParamsSchema: idPathSchema,
+    querySchema: taskIntentionListQuerySchemaV2,
+    responseSchema: paginatedTaskIntentionResponseSchema.schema,
+    responseComponent: paginatedTaskIntentionResponseSchema,
+    parameters: [pathStringParam("id", { en: "Task id", zh: "\u4EFB\u52A1 id" }), ...taskIntentionListParameters],
+    errorStatuses: [400, 404, 500]
+  }),
+  defineOperationSpec({
+    baseOperationId: "tasksCreate",
+    method: "POST",
+    tag: "Tasks",
+    auth: "bearer",
+    summary: { en: "Publish task", zh: "\u53D1\u5E03\u4EFB\u52A1" },
+    pathTemplate: "/v2/tasks",
+    bodySchema: createTaskRequestSchema.schema,
+    requestBodyComponent: createTaskRequestSchema,
+    responseSchema: taskSchema.schema,
+    responseComponent: taskSchema,
+    errorStatuses: [400, 401, 409, 500]
+  }),
+  defineOperationSpec({
+    baseOperationId: "tasksAddIntention",
+    method: "POST",
+    tag: "Tasks",
+    auth: "bearer",
+    summary: { en: "Add task intention", zh: "\u767B\u8BB0\u4EFB\u52A1\u610F\u5411" },
+    pathTemplate: "/v2/tasks/{id}/intentions",
+    pathParamsSchema: idPathSchema,
+    responseSchema: taskIntentionSchema.schema,
+    responseComponent: taskIntentionSchema,
+    parameters: [pathStringParam("id", { en: "Task id", zh: "\u4EFB\u52A1 id" })],
+    errorStatuses: [401, 404, 409, 500]
+  }),
+  defineOperationSpec({
+    baseOperationId: "tasksSubmit",
+    method: "POST",
+    tag: "Tasks",
+    auth: "bearer",
+    summary: { en: "Submit task output", zh: "\u63D0\u4EA4\u4EFB\u52A1\u7ED3\u679C" },
+    pathTemplate: "/v2/tasks/{id}/submissions",
+    pathParamsSchema: idPathSchema,
+    bodySchema: submitTaskRequestSchema.schema,
+    requestBodyComponent: submitTaskRequestSchema,
+    responseSchema: submissionSchema.schema,
+    responseComponent: submissionSchema,
+    parameters: [pathStringParam("id", { en: "Task id", zh: "\u4EFB\u52A1 id" })],
+    errorStatuses: [400, 401, 404, 409, 500]
+  }),
+  defineOperationSpec({
+    baseOperationId: "tasksTerminate",
+    method: "POST",
+    tag: "Tasks",
+    auth: "bearer",
+    summary: { en: "Terminate task", zh: "\u7EC8\u6B62\u4EFB\u52A1" },
+    pathTemplate: "/v2/tasks/{id}/terminate",
+    pathParamsSchema: idPathSchema,
+    responseSchema: taskSchema.schema,
+    responseComponent: taskSchema,
+    parameters: [pathStringParam("id", { en: "Task id", zh: "\u4EFB\u52A1 id" })],
+    errorStatuses: [401, 403, 404, 409, 500]
+  }),
+  defineOperationSpec({
+    baseOperationId: "submissionsList",
+    method: "GET",
+    tag: "Submissions",
+    auth: "none",
+    summary: { en: "List submissions", zh: "\u67E5\u8BE2\u63D0\u4EA4\u5217\u8868" },
+    pathTemplate: "/v2/submissions",
+    querySchema: submissionListQuerySchemaV2,
+    responseSchema: paginatedSubmissionResponseSchema.schema,
+    responseComponent: paginatedSubmissionResponseSchema,
+    parameters: submissionListParameters,
+    errorStatuses: [400, 500]
+  }),
+  defineOperationSpec({
+    baseOperationId: "submissionsGet",
+    method: "GET",
+    tag: "Submissions",
+    auth: "none",
+    summary: { en: "Get submission", zh: "\u8BFB\u53D6\u63D0\u4EA4\u8BE6\u60C5" },
+    pathTemplate: "/v2/submissions/{id}",
+    pathParamsSchema: idPathSchema,
+    responseSchema: submissionSchema.schema,
+    responseComponent: submissionSchema,
+    parameters: [pathStringParam("id", { en: "Submission id", zh: "\u63D0\u4EA4 id" })],
+    errorStatuses: [404, 500]
+  }),
+  defineOperationSpec({
+    baseOperationId: "submissionsConfirm",
+    method: "POST",
+    tag: "Submissions",
+    auth: "bearer",
+    summary: { en: "Confirm submission", zh: "\u786E\u8BA4\u63D0\u4EA4" },
+    pathTemplate: "/v2/submissions/{id}/confirm",
+    pathParamsSchema: idPathSchema,
+    responseSchema: submissionSchema.schema,
+    responseComponent: submissionSchema,
+    parameters: [pathStringParam("id", { en: "Submission id", zh: "\u63D0\u4EA4 id" })],
+    errorStatuses: [401, 403, 404, 409, 500]
+  }),
+  defineOperationSpec({
+    baseOperationId: "submissionsReject",
+    method: "POST",
+    tag: "Submissions",
+    auth: "bearer",
+    summary: { en: "Reject submission", zh: "\u62D2\u7EDD\u63D0\u4EA4" },
+    pathTemplate: "/v2/submissions/{id}/reject",
+    pathParamsSchema: idPathSchema,
+    responseSchema: submissionSchema.schema,
+    responseComponent: submissionSchema,
+    parameters: [pathStringParam("id", { en: "Submission id", zh: "\u63D0\u4EA4 id" })],
+    errorStatuses: [401, 403, 404, 409, 500]
+  }),
+  defineOperationSpec({
+    baseOperationId: "disputesList",
+    method: "GET",
+    tag: "Disputes",
+    auth: "none",
+    summary: { en: "List disputes", zh: "\u67E5\u8BE2\u4E89\u8BAE\u5217\u8868" },
+    pathTemplate: "/v2/disputes",
+    querySchema: disputeListQuerySchemaV2,
+    responseSchema: paginatedDisputeResponseSchema.schema,
+    responseComponent: paginatedDisputeResponseSchema,
+    parameters: disputeListParameters,
+    errorStatuses: [400, 500]
+  }),
+  defineOperationSpec({
+    baseOperationId: "disputesGet",
+    method: "GET",
+    tag: "Disputes",
+    auth: "none",
+    summary: { en: "Get dispute", zh: "\u8BFB\u53D6\u4E89\u8BAE\u8BE6\u60C5" },
+    pathTemplate: "/v2/disputes/{id}",
+    pathParamsSchema: idPathSchema,
+    responseSchema: disputeSchema.schema,
+    responseComponent: disputeSchema,
+    parameters: [pathStringParam("id", { en: "Dispute id", zh: "\u4E89\u8BAE id" })],
+    errorStatuses: [404, 500]
+  }),
+  defineOperationSpec({
+    baseOperationId: "disputesOpen",
+    method: "POST",
+    tag: "Disputes",
+    auth: "bearer",
+    summary: { en: "Open dispute", zh: "\u53D1\u8D77\u4E89\u8BAE" },
+    pathTemplate: "/v2/disputes",
+    bodySchema: openDisputeRequestSchema.schema,
+    requestBodyComponent: openDisputeRequestSchema,
+    responseSchema: disputeSchema.schema,
+    responseComponent: disputeSchema,
+    errorStatuses: [400, 401, 403, 404, 409, 500]
+  }),
+  defineOperationSpec({
+    baseOperationId: "disputesVote",
+    method: "POST",
+    tag: "Disputes",
+    auth: "bearer",
+    summary: { en: "Vote on dispute", zh: "\u5BF9\u4E89\u8BAE\u6295\u7968" },
+    pathTemplate: "/v2/disputes/{id}/votes",
+    pathParamsSchema: idPathSchema,
+    bodySchema: voteDisputeRequestSchema.schema,
+    requestBodyComponent: voteDisputeRequestSchema,
+    responseSchema: voteDisputeResultSchema.schema,
+    responseComponent: voteDisputeResultSchema,
+    parameters: [pathStringParam("id", { en: "Dispute id", zh: "\u4E89\u8BAE id" })],
+    errorStatuses: [400, 401, 403, 404, 409, 500]
+  }),
+  defineOperationSpec({
+    baseOperationId: "activitiesList",
+    method: "GET",
+    tag: "Activities",
+    auth: "none",
+    summary: { en: "List activity events", zh: "\u67E5\u8BE2\u6D3B\u52A8\u4E8B\u4EF6\u6D41" },
+    pathTemplate: "/v2/activities",
+    querySchema: activityListQuerySchemaV2,
+    responseSchema: paginatedActivityResponseSchema.schema,
+    responseComponent: paginatedActivityResponseSchema,
+    parameters: activityListParameters,
+    errorStatuses: [400, 500]
+  }),
+  defineOperationSpec({
+    baseOperationId: "dashboardSummary",
+    method: "GET",
+    tag: "Dashboard",
+    auth: "none",
+    summary: { en: "Get dashboard summary", zh: "\u8BFB\u53D6\u770B\u677F\u6C47\u603B" },
+    pathTemplate: "/v2/dashboard/summary",
+    querySchema: dashboardSummaryQuerySchema,
+    responseSchema: dashboardSummaryResponseSchema.schema,
+    responseComponent: dashboardSummaryResponseSchema,
+    parameters: dashboardSummaryParameters,
+    errorStatuses: [400, 500]
+  }),
+  defineOperationSpec({
+    baseOperationId: "dashboardTrends",
+    method: "GET",
+    tag: "Dashboard",
+    auth: "none",
+    summary: { en: "Get dashboard trends", zh: "\u8BFB\u53D6\u770B\u677F\u8D8B\u52BF" },
+    pathTemplate: "/v2/dashboard/trends",
+    querySchema: dashboardTrendsQuerySchema,
+    responseSchema: dashboardTrendsResponseSchema.schema,
+    responseComponent: dashboardTrendsResponseSchema,
+    parameters: dashboardTrendParameters,
+    errorStatuses: [400, 500]
+  }),
+  defineOperationSpec({
+    baseOperationId: "agentsList",
+    method: "GET",
+    tag: "Agents",
+    auth: "none",
+    summary: { en: "List agents", zh: "\u67E5\u8BE2 Agent \u5217\u8868" },
+    pathTemplate: "/v2/agents",
+    querySchema: agentListQuerySchemaV2,
+    responseSchema: paginatedAgentDirectoryResponseSchema.schema,
+    responseComponent: paginatedAgentDirectoryResponseSchema,
+    parameters: agentListParameters,
+    errorStatuses: [400, 500]
+  }),
+  defineOperationSpec({
+    baseOperationId: "agentsGetProfile",
+    method: "GET",
+    tag: "Agents",
+    auth: "none",
+    summary: { en: "Get agent profile", zh: "\u8BFB\u53D6 Agent \u8D44\u6599" },
+    pathTemplate: "/v2/agents/{address}",
+    pathParamsSchema: addressPathSchema,
+    responseSchema: agentProfileSchema.schema,
+    responseComponent: agentProfileSchema,
+    parameters: [pathStringParam("address", { en: "Agent address", zh: "Agent \u5730\u5740" }, { type: "string", pattern: "^0x[a-fA-F0-9]{40}$" })],
+    errorStatuses: [400, 500]
+  }),
+  defineOperationSpec({
+    baseOperationId: "agentsUpdateProfile",
+    method: "PATCH",
+    tag: "Agents",
+    auth: "bearer",
+    summary: { en: "Update agent profile", zh: "\u66F4\u65B0 Agent \u8D44\u6599" },
+    pathTemplate: "/v2/agents/{address}/profile",
+    pathParamsSchema: addressPathSchema,
+    bodySchema: updateAgentProfileRequestSchema.schema,
+    requestBodyComponent: updateAgentProfileRequestSchema,
+    responseSchema: agentProfileSchema.schema,
+    responseComponent: agentProfileSchema,
+    parameters: [pathStringParam("address", { en: "Agent address", zh: "Agent \u5730\u5740" }, { type: "string", pattern: "^0x[a-fA-F0-9]{40}$" })],
+    errorStatuses: [400, 401, 403, 500]
+  }),
+  defineOperationSpec({
+    baseOperationId: "agentsGetStats",
+    method: "GET",
+    tag: "Agents",
+    auth: "none",
+    summary: { en: "Get agent stats", zh: "\u8BFB\u53D6 Agent \u7EDF\u8BA1" },
+    pathTemplate: "/v2/agents/{address}/stats",
+    pathParamsSchema: addressPathSchema,
+    responseSchema: agentStatsSchema.schema,
+    responseComponent: agentStatsSchema,
+    parameters: [pathStringParam("address", { en: "Agent address", zh: "Agent \u5730\u5740" }, { type: "string", pattern: "^0x[a-fA-F0-9]{40}$" })],
+    errorStatuses: [400, 500]
+  }),
+  defineOperationSpec({
+    baseOperationId: "ledgerGet",
+    method: "GET",
+    tag: "Ledger",
+    auth: "none",
+    summary: { en: "Get ledger balance", zh: "\u8BFB\u53D6\u8D26\u672C\u4F59\u989D" },
+    pathTemplate: "/v2/ledger/{address}",
+    pathParamsSchema: addressPathSchema,
+    responseSchema: ledgerBalanceSchema.schema,
+    responseComponent: ledgerBalanceSchema,
+    parameters: [pathStringParam("address", { en: "Agent address", zh: "Agent \u5730\u5740" }, { type: "string", pattern: "^0x[a-fA-F0-9]{40}$" })],
+    errorStatuses: [400, 500]
+  }),
+  defineOperationSpec({
+    baseOperationId: "cyclesList",
+    method: "GET",
+    tag: "Cycles",
+    auth: "none",
+    summary: { en: "List cycles", zh: "\u67E5\u8BE2\u5468\u671F\u5217\u8868" },
+    pathTemplate: "/v2/cycles",
+    querySchema: cycleListQuerySchemaV2,
+    responseSchema: paginatedCycleResponseSchema.schema,
+    responseComponent: paginatedCycleResponseSchema,
+    parameters: cycleListParametersV2,
+    errorStatuses: [500]
+  }),
+  defineOperationSpec({
+    baseOperationId: "cyclesGetActive",
+    method: "GET",
+    tag: "Cycles",
+    auth: "none",
+    summary: { en: "Get active cycle", zh: "\u8BFB\u53D6\u5F53\u524D\u5468\u671F" },
+    pathTemplate: "/v2/cycles/active",
+    responseSchema: cycleSchema.schema,
+    responseComponent: cycleSchema,
+    errorStatuses: [404, 500]
+  }),
+  defineOperationSpec({
+    baseOperationId: "cyclesGet",
+    method: "GET",
+    tag: "Cycles",
+    auth: "none",
+    summary: { en: "Get cycle", zh: "\u8BFB\u53D6\u5468\u671F\u8BE6\u60C5" },
+    pathTemplate: "/v2/cycles/{id}",
+    pathParamsSchema: idPathSchema,
+    responseSchema: cycleSchema.schema,
+    responseComponent: cycleSchema,
+    parameters: [pathStringParam("id", { en: "Cycle id", zh: "\u5468\u671F id" })],
+    errorStatuses: [404, 500]
+  }),
+  defineOperationSpec({
+    baseOperationId: "cyclesGetRewards",
+    method: "GET",
+    tag: "Cycles",
+    auth: "none",
+    summary: { en: "Get cycle rewards", zh: "\u8BFB\u53D6\u5468\u671F\u5956\u52B1\u89C6\u56FE" },
+    pathTemplate: "/v2/cycles/{id}/rewards",
+    pathParamsSchema: idPathSchema,
+    responseSchema: cycleRewardsResponseSchema.schema,
+    responseComponent: cycleRewardsResponseSchema,
+    parameters: [pathStringParam("id", { en: "Cycle id", zh: "\u5468\u671F id" })],
+    errorStatuses: [404, 500]
+  }),
+  defineOperationSpec({
+    baseOperationId: "economyGetParams",
+    method: "GET",
+    tag: "Economy",
+    auth: "none",
+    summary: { en: "Get public economy params", zh: "\u8BFB\u53D6\u516C\u5F00\u7ECF\u6D4E\u53C2\u6570" },
+    pathTemplate: "/v2/economy/params",
+    responseSchema: publicEconomyParamsSchema.schema,
+    responseComponent: publicEconomyParamsSchema,
+    errorStatuses: [500]
+  }),
+  defineOperationSpec({
+    baseOperationId: "adminCloseCycle",
+    method: "POST",
+    tag: "Admin",
+    auth: "admin",
+    summary: { en: "Close current cycle", zh: "\u5173\u95ED\u5F53\u524D\u5468\u671F" },
+    pathTemplate: "/v2/admin/cycles/close",
+    responseSchema: closeCycleResultSchema.schema,
+    responseComponent: closeCycleResultSchema,
+    errorStatuses: [401, 409, 500]
+  }),
+  defineOperationSpec({
+    baseOperationId: "adminOverrideDispute",
+    method: "POST",
+    tag: "Admin",
+    auth: "admin",
+    summary: { en: "Override dispute", zh: "\u7BA1\u7406\u5458\u8986\u76D6\u4E89\u8BAE\u7ED3\u679C" },
+    description: {
+      en: "NOT_COMPLETED reopens dispute to OPEN. If another OPEN dispute already exists for the same submission, returns 409 OPEN_DISPUTE_ALREADY_EXISTS.",
+      zh: "NOT_COMPLETED \u4F1A\u5C06\u4E89\u8BAE\u91CD\u5F00\u4E3A OPEN\u3002\u82E5\u540C\u4E00 submission \u5DF2\u5B58\u5728\u5176\u4ED6 OPEN \u4E89\u8BAE\uFF0C\u5219\u8FD4\u56DE 409 OPEN_DISPUTE_ALREADY_EXISTS\u3002"
+    },
+    pathTemplate: "/v2/admin/disputes/{id}/override",
+    pathParamsSchema: idPathSchema,
+    bodySchema: overrideDisputeRequestSchema.schema,
+    requestBodyComponent: overrideDisputeRequestSchema,
+    responseSchema: disputeSchema.schema,
+    responseComponent: disputeSchema,
+    parameters: [pathStringParam("id", { en: "Dispute id", zh: "\u4E89\u8BAE id" })],
+    errorStatuses: [401, 404, 409, 500]
+  }),
+  defineOperationSpec({
+    baseOperationId: "adminBridgeExport",
+    method: "POST",
+    tag: "Admin",
+    auth: "admin",
+    summary: { en: "Export bridge batch", zh: "\u5BFC\u51FA\u6865\u63A5\u6279\u6B21" },
+    pathTemplate: "/v2/admin/bridge/export",
+    bodySchema: bridgeExportRequestSchema.schema,
+    requestBodyComponent: bridgeExportRequestSchema,
+    responseSchema: bridgeExportResponseSchema.schema,
+    responseComponent: bridgeExportResponseSchema,
+    errorStatuses: [400, 401, 500]
+  })
+];
+var supportedApiVersions = [...new Set(apiOperations.map((operation) => operation.version))];
+var apiOperationsById = new Map(
+  apiOperations.map((operation) => [operation.operationId, operation])
+);
+var getApiOperation = (operationId) => {
+  const operation = apiOperationsById.get(operationId);
+  if (!operation) {
+    throw new Error(`unknown api operation: ${operationId}`);
+  }
+  return operation;
+};
+var buildOperationPath = (operation, input = {}) => {
+  let path = operation.pathTemplate;
+  if (input.pathParams) {
+    for (const [key, value] of Object.entries(input.pathParams)) {
+      path = path.replace(`{${key}}`, encodeURIComponent(String(value)));
+    }
+  }
+  const query = new URLSearchParams();
+  for (const [key, value] of Object.entries(input.query ?? {})) {
+    if (value === void 0 || value === null) {
+      continue;
+    }
+    query.set(key, String(value));
+  }
+  const suffix = query.toString();
+  return suffix.length > 0 ? `${path}?${suffix}` : path;
+};
+var stripApiVersionPrefix = (path) => {
+  const stripped = path.replace(/^\/v\d+(?=\/|$)/, "");
+  return stripped.length > 0 ? stripped : "/";
+};
+var buildVersionlessOperationPath = (operation, input = {}) => stripApiVersionPrefix(buildOperationPath(operation, input));
+
+// ../../packages/sdk/src/index.ts
+var ApiClientError = class extends Error {
+  httpStatus;
+  apiError;
+  issues;
+  retryable;
+  responseBody;
+  constructor(message, options = {}) {
+    super(message);
+    this.name = "ApiClientError";
+    this.httpStatus = options.httpStatus ?? null;
+    this.apiError = options.apiError ?? null;
+    this.issues = options.issues ?? null;
+    this.retryable = options.retryable ?? false;
+    this.responseBody = options.responseBody ?? null;
+  }
+};
+var DEFAULT_TIMEOUT_MS = 1e4;
+var DEFAULT_RETRIES = 1;
+var sleep = async (ms) => {
+  await new Promise((resolve) => setTimeout(resolve, ms));
+};
+var shouldRetryStatus = (status) => status === 429 || status >= 500;
+var retryDelayMs = (attempt) => Math.min(1e3, 100 * 2 ** (attempt - 1));
+var isAbortError = (error) => error instanceof Error && error.name === "AbortError";
+var parseApiError = (body) => {
+  if (!body || typeof body !== "object") {
+    return null;
+  }
+  const envelope = body;
+  if (typeof envelope.error === "string") {
+    return {
+      code: envelope.error,
+      message: typeof envelope.message === "string" ? envelope.message : void 0,
+      details: envelope.issues
+    };
+  }
+  if (envelope.error && typeof envelope.error === "object") {
+    const nested = envelope.error;
+    if (typeof nested.code === "string") {
+      return {
+        code: nested.code,
+        message: typeof nested.message === "string" ? nested.message : void 0,
+        details: nested.details
+      };
+    }
+  }
+  return null;
+};
+var parseResponseBody = async (response) => {
+  if (response.status === 204) {
+    return null;
+  }
+  const text = await response.text();
+  if (text.length === 0) {
+    return null;
+  }
+  const contentType = response.headers.get("content-type") ?? "";
+  if (contentType.includes("application/json")) {
+    try {
+      return JSON.parse(text);
+    } catch {
+      return text;
+    }
+  }
+  return text;
+};
+var hasHeader = (headers, key) => {
+  const lower = key.toLowerCase();
+  return Object.keys(headers).some((header) => header.toLowerCase() === lower);
+};
+var AgentradeApiClient = class {
+  baseUrl;
+  token;
+  adminKey;
+  preferVersionlessPaths;
+  timeoutMs;
+  retries;
+  fetchImpl;
+  constructor(options) {
+    this.baseUrl = options.baseUrl.replace(/\/$/, "");
+    this.token = options.token;
+    this.adminKey = options.adminKey;
+    this.preferVersionlessPaths = options.preferVersionlessPaths ?? true;
+    this.timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    this.retries = options.retries ?? DEFAULT_RETRIES;
+    this.fetchImpl = options.fetchImpl ?? fetch;
+  }
+  setToken(token) {
+    this.token = token;
+  }
+  setAdminKey(adminKey) {
+    this.adminKey = adminKey;
+  }
+  setTimeoutMs(timeoutMs) {
+    this.timeoutMs = timeoutMs;
+  }
+  setRetries(retries) {
+    this.retries = retries;
+  }
+  resolveAuthHeaders(auth) {
+    if (auth === "bearer") {
+      if (!this.token) {
+        throw new ApiClientError("missing bearer token for authenticated request", {
+          apiError: "MISSING_BEARER_TOKEN"
+        });
+      }
+      return { authorization: `Bearer ${this.token}` };
+    }
+    if (auth === "admin") {
+      if (!this.adminKey) {
+        throw new ApiClientError("missing admin service key for admin request", {
+          apiError: "MISSING_ADMIN_KEY"
+        });
+      }
+      return { "x-admin-service-key": this.adminKey };
+    }
+    return {};
+  }
+  async requestRaw(options) {
+    const retries = Math.max(0, options.retries ?? this.retries);
+    const maxAttempts = retries + 1;
+    const timeoutMs = Math.max(1, options.timeoutMs ?? this.timeoutMs);
+    let lastError;
+    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), timeoutMs);
+      try {
+        const authHeaders = this.resolveAuthHeaders(options.auth);
+        const headers = {
+          ...authHeaders
+        };
+        let body;
+        if (options.body !== void 0) {
+          body = JSON.stringify(options.body);
+          if (!hasHeader(headers, "content-type")) {
+            headers["content-type"] = "application/json";
+          }
+        }
+        const response = await this.fetchImpl(`${this.baseUrl}${options.path}`, {
+          method: options.method,
+          headers,
+          body,
+          signal: controller.signal
+        });
+        const payload = await parseResponseBody(response);
+        if (!response.ok) {
+          const envelope = parseApiError(payload);
+          const retryable = shouldRetryStatus(response.status);
+          if (retryable && attempt < maxAttempts) {
+            await sleep(retryDelayMs(attempt));
+            continue;
+          }
+          throw new ApiClientError(
+            envelope?.message ?? `HTTP ${response.status} request failed`,
+            {
+              httpStatus: response.status,
+              apiError: envelope?.code ?? null,
+              issues: envelope?.details ?? null,
+              retryable,
+              responseBody: payload
+            }
+          );
+        }
+        return payload;
+      } catch (error) {
+        if (error instanceof ApiClientError) {
+          throw error;
+        }
+        const retryable = isAbortError(error) || error instanceof TypeError;
+        lastError = error;
+        if (retryable && attempt < maxAttempts) {
+          await sleep(retryDelayMs(attempt));
+          continue;
+        }
+        throw new ApiClientError(
+          error instanceof Error ? error.message : "network request failed",
+          {
+            retryable,
+            responseBody: null
+          }
+        );
+      } finally {
+        clearTimeout(timer);
+      }
+    }
+    throw new ApiClientError(lastError instanceof Error ? lastError.message : "request failed", {
+      retryable: false
+    });
+  }
+  async requestOperation(operationId, input = {}) {
+    const operation = getApiOperation(operationId);
+    const path = this.preferVersionlessPaths ? buildVersionlessOperationPath(operation, {
+      pathParams: input.pathParams,
+      query: input.query
+    }) : buildOperationPath(operation, {
+      pathParams: input.pathParams,
+      query: input.query
+    });
+    const payload = await this.requestRaw({
+      method: operation.method,
+      path,
+      auth: input.auth ?? operation.auth,
+      body: input.body,
+      timeoutMs: input.timeoutMs,
+      retries: input.retries
+    });
+    return operation.responseSchema.parse(payload);
+  }
+  health() {
+    return this.requestOperation("systemHealthV2");
+  }
+  metrics() {
+    return this.requestOperation("systemMetricsV2");
+  }
+  authChallenge(payload) {
+    return this.requestOperation("authChallengeV2", { body: payload });
+  }
+  authVerify(payload) {
+    return this.requestOperation("authVerifyV2", { body: payload });
+  }
+  getTasks(params) {
+    return this.requestOperation("tasksListV2", { query: params });
+  }
+  getTask(taskId) {
+    return this.requestOperation("tasksGetV2", {
+      pathParams: { id: taskId }
+    });
+  }
+  createTask(payload) {
+    return this.requestOperation("tasksCreateV2", {
+      body: payload
+    });
+  }
+  getTaskIntentions(taskId, params) {
+    return this.requestOperation("tasksListIntentionsV2", {
+      pathParams: { id: taskId },
+      query: params
+    });
+  }
+  addTaskIntention(taskId) {
+    return this.requestOperation("tasksAddIntentionV2", {
+      pathParams: { id: taskId }
+    });
+  }
+  submitTask(taskId, payload) {
+    return this.requestOperation("tasksSubmitV2", {
+      pathParams: { id: taskId },
+      body: payload
+    });
+  }
+  terminateTask(taskId) {
+    return this.requestOperation("tasksTerminateV2", {
+      pathParams: { id: taskId }
+    });
+  }
+  confirmSubmission(submissionId) {
+    return this.requestOperation("submissionsConfirmV2", {
+      pathParams: { id: submissionId }
+    });
+  }
+  rejectSubmission(submissionId) {
+    return this.requestOperation("submissionsRejectV2", {
+      pathParams: { id: submissionId }
+    });
+  }
+  getSubmissions(params) {
+    return this.requestOperation("submissionsListV2", {
+      query: params
+    });
+  }
+  getSubmission(submissionId) {
+    return this.requestOperation("submissionsGetV2", {
+      pathParams: { id: submissionId }
+    });
+  }
+  getDisputes(params) {
+    return this.requestOperation("disputesListV2", {
+      query: params
+    });
+  }
+  getDispute(disputeId) {
+    return this.requestOperation("disputesGetV2", {
+      pathParams: { id: disputeId }
+    });
+  }
+  openDispute(payload) {
+    return this.requestOperation("disputesOpenV2", {
+      body: payload
+    });
+  }
+  voteDispute(disputeId, payload) {
+    return this.requestOperation("disputesVoteV2", {
+      pathParams: { id: disputeId },
+      body: payload
+    });
+  }
+  getAgentProfile(address) {
+    return this.requestOperation("agentsGetProfileV2", {
+      pathParams: { address }
+    });
+  }
+  getAgents(params) {
+    return this.requestOperation("agentsListV2", {
+      query: params
+    });
+  }
+  updateAgentProfile(address, payload) {
+    return this.requestOperation("agentsUpdateProfileV2", {
+      pathParams: { address },
+      body: payload
+    });
+  }
+  getAgentStats(address) {
+    return this.requestOperation("agentsGetStatsV2", {
+      pathParams: { address }
+    });
+  }
+  getActivities(params) {
+    return this.requestOperation("activitiesListV2", {
+      query: params
+    });
+  }
+  getDashboardSummary(params) {
+    return this.requestOperation("dashboardSummaryV2", {
+      query: params
+    });
+  }
+  getDashboardTrends(params) {
+    return this.requestOperation("dashboardTrendsV2", {
+      query: params
+    });
+  }
+  getLedger(address) {
+    return this.requestOperation("ledgerGetV2", {
+      pathParams: { address }
+    });
+  }
+  getCycles(params) {
+    return this.requestOperation("cyclesListV2", {
+      query: params
+    });
+  }
+  getActiveCycle() {
+    return this.requestOperation("cyclesGetActiveV2");
+  }
+  getCycle(cycleId) {
+    return this.requestOperation("cyclesGetV2", {
+      pathParams: { id: cycleId }
+    });
+  }
+  getCycleRewards(cycleId) {
+    return this.requestOperation("cyclesGetRewardsV2", {
+      pathParams: { id: cycleId }
+    });
+  }
+  getEconomyParams() {
+    return this.requestOperation("economyGetParamsV2");
+  }
+  closeCurrentCycleAdmin() {
+    return this.requestOperation("adminCloseCycleV2");
+  }
+  overrideDisputeAdmin(disputeId, payload) {
+    return this.requestOperation("adminOverrideDisputeV2", {
+      pathParams: { id: disputeId },
+      body: payload
+    });
+  }
+  exportBridgeBatchAdmin(payload = {}) {
+    return this.requestOperation("adminBridgeExportV2", {
+      body: payload
+    });
+  }
+};
+
+// src/context.ts
+var resolveCommandPath = (command) => {
+  const segments = [];
+  let cursor = command;
+  while (cursor && cursor.name() !== "agentrade") {
+    segments.push(cursor.name());
+    cursor = cursor.parent ?? null;
+  }
+  return segments.reverse().join(" ");
+};
+var normalizeOptional = (value) => {
+  if (!value) {
+    return void 0;
+  }
+  return value.trim().length > 0 ? value : void 0;
+};
+var resolveGlobalOptions = (command) => {
+  const raw = command.optsWithGlobals();
+  const rawBaseUrl = normalizeOptional(raw.baseUrl);
+  if (!rawBaseUrl) {
+    throw new CliConfigError("--base-url is required");
+  }
+  const baseUrl = ensureHttpUrl(rawBaseUrl, "--base-url");
+  const timeoutMs = typeof raw.timeoutMs === "number" ? raw.timeoutMs : ensurePositiveInteger(String(raw.timeoutMs ?? "10000"), "--timeout-ms");
+  const retries = typeof raw.retries === "number" ? raw.retries : ensureNonNegativeInteger(String(raw.retries ?? "1"), "--retries");
+  return {
+    baseUrl,
+    token: normalizeOptional(raw.token),
+    adminKey: normalizeOptional(raw.adminKey),
+    timeoutMs,
+    retries,
+    pretty: Boolean(raw.pretty)
+  };
+};
+var createCommandContext = (command) => {
+  const options = resolveGlobalOptions(command);
+  const client = new AgentradeApiClient({
+    baseUrl: options.baseUrl,
+    token: options.token,
+    adminKey: options.adminKey,
+    timeoutMs: options.timeoutMs,
+    retries: options.retries
+  });
+  return {
+    commandPath: resolveCommandPath(command),
+    options,
+    client,
+    requireToken: () => {
+      if (!options.token) {
+        throw new CliConfigError("missing token: use --token or AGENTRADE_TOKEN");
+      }
+      return options.token;
+    },
+    requireAdminKey: () => {
+      if (!options.adminKey) {
+        throw new CliConfigError("missing admin key: use --admin-key or AGENTRADE_ADMIN_SERVICE_KEY");
+      }
+      return options.adminKey;
+    }
+  };
+};
+
+// src/output.ts
+var isCommanderError = (error) => {
+  if (!error || typeof error !== "object") {
+    return false;
+  }
+  const value = error;
+  return typeof value.message === "string" && typeof value.code === "string" && value.code.startsWith("commander.");
+};
+var shouldSuppressCommanderError = (error) => {
+  if (!isCommanderError(error)) {
+    return false;
+  }
+  const exitCode = Number(error.exitCode ?? 1);
+  return error.code === "commander.helpDisplayed" || exitCode === 0;
+};
+var messageOf = (error) => {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+};
+var commandFromError = (error) => {
+  if (!error || typeof error !== "object") {
+    return void 0;
+  }
+  const value = error;
+  return typeof value.commandPath === "string" ? value.commandPath : void 0;
+};
+var printJson = (value, pretty) => {
+  process.stdout.write(`${JSON.stringify(value, null, pretty ? 2 : 0)}
+`);
+};
+var printErrorJson = (value) => {
+  process.stderr.write(`${JSON.stringify(value)}
+`);
+};
+var normalizeCliError = (error, fallbackCommand) => {
+  const command = commandFromError(error) ?? fallbackCommand;
+  if (error instanceof CliValidationError || isCommanderError(error)) {
+    return {
+      output: {
+        type: "VALIDATION_ERROR",
+        message: messageOf(error),
+        httpStatus: null,
+        apiError: null,
+        issues: null,
+        retryable: false,
+        command
+      },
+      exitCode: 2 /* VALIDATION */
+    };
+  }
+  if (error instanceof CliConfigError) {
+    return {
+      output: {
+        type: "CONFIG_ERROR",
+        message: error.message,
+        httpStatus: null,
+        apiError: null,
+        issues: null,
+        retryable: false,
+        command
+      },
+      exitCode: 3 /* CONFIG */
+    };
+  }
+  if (error instanceof ApiClientError) {
+    if (error.apiError === "MISSING_BEARER_TOKEN" || error.apiError === "MISSING_ADMIN_KEY") {
+      return {
+        output: {
+          type: "CONFIG_ERROR",
+          message: error.message,
+          httpStatus: null,
+          apiError: error.apiError,
+          issues: error.issues,
+          retryable: false,
+          command
+        },
+        exitCode: 3 /* CONFIG */
+      };
+    }
+    if (error.httpStatus !== null) {
+      return {
+        output: {
+          type: "API_ERROR",
+          message: error.message,
+          httpStatus: error.httpStatus,
+          apiError: error.apiError,
+          issues: error.issues,
+          retryable: error.retryable,
+          command
+        },
+        exitCode: 4 /* API */
+      };
+    }
+    return {
+      output: {
+        type: "NETWORK_ERROR",
+        message: error.message,
+        httpStatus: null,
+        apiError: error.apiError,
+        issues: error.issues,
+        retryable: error.retryable,
+        command
+      },
+      exitCode: 5 /* NETWORK */
+    };
+  }
+  return {
+    output: {
+      type: "UNKNOWN_ERROR",
+      message: messageOf(error),
+      httpStatus: null,
+      apiError: null,
+      issues: null,
+      retryable: false,
+      command
+    },
+    exitCode: 10 /* UNKNOWN */
+  };
+};
+
+// src/commands/shared.ts
+var enrichErrorWithCommandPath = (error, commandPath) => {
+  if (!error || typeof error !== "object") {
+    return;
+  }
+  const enriched = error;
+  if (!enriched.commandPath) {
+    enriched.commandPath = commandPath;
+  }
+};
+var executeJsonCommand = async (command, handler) => {
+  const ctx = createCommandContext(command);
+  try {
+    const result = await handler(ctx);
+    printJson(result, ctx.options.pretty);
+  } catch (error) {
+    enrichErrorWithCommandPath(error, ctx.commandPath);
+    throw error;
+  }
+};
+var executeOperationCommand = async (command, operationId, buildInput) => {
+  await executeJsonCommand(command, async (ctx) => {
+    const input = buildInput ? await buildInput(ctx) : {};
+    return ctx.client.requestOperation(operationId, input);
+  });
+};
+var executeBearerOperationCommand = async (command, operationId, buildInput) => {
+  await executeJsonCommand(command, async (ctx) => {
+    ctx.requireToken();
+    const input = buildInput ? await buildInput(ctx) : {};
+    return ctx.client.requestOperation(operationId, input);
+  });
+};
+var executeAdminOperationCommand = async (command, operationId, buildInput) => {
+  await executeJsonCommand(command, async (ctx) => {
+    ctx.requireAdminKey();
+    const input = buildInput ? await buildInput(ctx) : {};
+    return ctx.client.requestOperation(operationId, input);
+  });
+};
+
+// src/commands/admin.ts
+var registerAdminCommands = (program) => {
+  const admin = program.command("admin").description("Admin-only commands");
+  const adminCycles = admin.command("cycles").description("Cycle admin commands");
+  adminCycles.command("close").description("Close current cycle").action(async (_options, command) => {
+    await executeAdminOperationCommand(command, cliOperationBindings["admin cycles close"]);
+  });
+  const adminDisputes = admin.command("disputes").description("Dispute admin commands");
+  adminDisputes.command("override").description("Override dispute result").requiredOption("--dispute <id>", "dispute id").requiredOption("--result <result>", "COMPLETED or NOT_COMPLETED").action(async (options, command) => {
+    await executeAdminOperationCommand(command, cliOperationBindings["admin disputes override"], async () => ({
+      pathParams: { id: ensureNonEmpty(String(options.dispute), "--dispute") },
+      body: {
+        result: ensureOverrideResult(String(options.result))
+      }
+    }));
+  });
+  const adminBridge = admin.command("bridge").description("Bridge export commands");
+  adminBridge.command("export").description("Export bridge balances").option("--addresses <list>", "comma or whitespace separated addresses").option("--addresses-file <path>", "file containing comma or whitespace separated addresses").action(async (options, command) => {
+    await executeAdminOperationCommand(command, cliOperationBindings["admin bridge export"], async () => {
+      const rawAddresses = resolveTextInput({
+        inlineValue: options.addresses,
+        filePath: options.addressesFile,
+        fieldName: "addresses",
+        required: false,
+        allowEmpty: true
+      });
+      const addresses = parseOptionalAddressList(rawAddresses, "--addresses");
+      return {
+        body: addresses ? { addresses } : {}
+      };
+    });
+  });
+};
+
+// src/commands/activities.ts
+var ensureActivityType = (raw) => {
+  const normalized = raw.trim().toUpperCase();
+  if (!Object.values(ActivityEventType).includes(normalized)) {
+    throw new CliValidationError(
+      "--type must be TASK_PUBLISHED|TASK_INTENDED|TASK_SUBMITTED|SUBMISSION_REJECTED|TASK_COMPLETED|DISPUTE_OPENED|TASK_TERMINATED"
+    );
+  }
+  return normalized;
+};
+var registerActivityCommands = (program) => {
+  const activities = program.command("activities").description("Activity timeline commands");
+  activities.command("list").description("List activity events").option("--task <id>", "filter by task id").option("--dispute <id>", "filter by dispute id").option("--address <address>", "filter by actor address").option(
+    "--type <type>",
+    "TASK_PUBLISHED|TASK_INTENDED|TASK_SUBMITTED|SUBMISSION_REJECTED|TASK_COMPLETED|DISPUTE_OPENED|TASK_TERMINATED"
+  ).option("--order <order>", "asc|desc").option("--cursor <offset>", "pagination cursor").option("--limit <number>", "page size").action(async (options, command) => {
+    await executeOperationCommand(command, cliOperationBindings["activities list"], async () => {
+      const type = typeof options.type === "string" ? ensureActivityType(options.type) : void 0;
+      return {
+        query: {
+          taskId: typeof options.task === "string" ? ensureNonEmpty(options.task, "--task") : void 0,
+          disputeId: typeof options.dispute === "string" ? ensureNonEmpty(options.dispute, "--dispute") : void 0,
+          address: typeof options.address === "string" ? ensureAddress(options.address, "--address") : void 0,
+          type,
+          order: typeof options.order === "string" ? options.order.trim().toLowerCase() : void 0,
+          cursor: typeof options.cursor === "string" ? ensureNonEmpty(options.cursor, "--cursor") : void 0,
+          limit: typeof options.limit === "string" ? ensurePositiveInteger(options.limit, "--limit") : void 0
+        }
+      };
+    });
+  });
+};
+
+// src/commands/agents.ts
+var registerAgentCommands = (program) => {
+  const agents = program.command("agents").description("Agent profile and stats commands");
+  agents.command("list").description("List agents").option("--q <text>", "search by address/name/bio").option("--active-only", "only include active agents").option("--sort <key>", "latest|score|reputation|completed|published|intented").option("--order <order>", "asc|desc").option("--cursor <offset>", "pagination cursor").option("--limit <number>", "page size").action(async (options, command) => {
+    await executeOperationCommand(command, cliOperationBindings["agents list"], async () => ({
+      query: {
+        q: typeof options.q === "string" ? ensureNonEmpty(options.q, "--q") : void 0,
+        activeOnly: options.activeOnly ? true : void 0,
+        sort: typeof options.sort === "string" ? options.sort.trim().toLowerCase() : void 0,
+        order: typeof options.order === "string" ? options.order.trim().toLowerCase() : void 0,
+        cursor: typeof options.cursor === "string" ? ensureNonEmpty(options.cursor, "--cursor") : void 0,
+        limit: typeof options.limit === "string" ? ensurePositiveInteger(options.limit, "--limit") : void 0
+      }
+    }));
+  });
+  const profile = agents.command("profile").description("Agent profile commands");
+  profile.command("get").description("Get agent profile").requiredOption("--address <address>", "agent address").action(async (options, command) => {
+    await executeOperationCommand(command, cliOperationBindings["agents profile get"], async () => ({
+      pathParams: { address: ensureAddress(String(options.address), "--address") }
+    }));
+  });
+  profile.command("update").description("Update own profile").requiredOption("--address <address>", "agent address").option("--name <text>", "profile display name").option("--name-file <path>", "file containing profile display name").option("--bio <text>", "profile bio").option("--bio-file <path>", "file containing profile bio").action(async (options, command) => {
+    await executeBearerOperationCommand(command, cliOperationBindings["agents profile update"], async () => {
+      const name = resolveTextInput({
+        inlineValue: options.name,
+        filePath: options.nameFile,
+        fieldName: "name",
+        required: false,
+        allowEmpty: true
+      });
+      const bio = resolveTextInput({
+        inlineValue: options.bio,
+        filePath: options.bioFile,
+        fieldName: "bio",
+        required: false,
+        allowEmpty: true
+      });
+      if (name === void 0 && bio === void 0) {
+        throw new CliValidationError("at least one of --name/--name-file or --bio/--bio-file must be provided");
+      }
+      return {
+        pathParams: { address: ensureAddress(String(options.address), "--address") },
+        body: {
+          ...name !== void 0 ? { name } : {},
+          ...bio !== void 0 ? { bio } : {}
+        }
+      };
+    });
+  });
+  agents.command("stats").description("Get agent stats").requiredOption("--address <address>", "agent address").action(async (options, command) => {
+    await executeOperationCommand(command, cliOperationBindings["agents stats"], async () => ({
+      pathParams: { address: ensureAddress(String(options.address), "--address") }
+    }));
+  });
+};
+
+// src/commands/auth.ts
+import { generatePrivateKey, privateKeyToAccount } from "viem/accounts";
+var registerAuthCommands = (program) => {
+  const auth = program.command("auth").description("Authentication commands");
+  const privateKeySecurityNotice = "PRIVATE KEY IS DISPLAYED ONLY ONCE. SAVE IT SECURELY NOW. NEVER SHARE, LOG, COMMIT, OR SCREENSHOT THIS KEY.";
+  auth.command("challenge").description("Request SIWE challenge message").requiredOption("--address <address>", "wallet address").action(async (options, command) => {
+    await executeOperationCommand(command, cliOperationBindings["auth challenge"], async () => ({
+      body: {
+        address: ensureAddress(String(options.address), "--address")
+      }
+    }));
+  });
+  auth.command("register").description("Create wallet, run SIWE challenge+verify, and return JWT (private key shown once)").action(async (_, command) => {
+    await executeJsonCommand(command, async (ctx) => {
+      const privateKey = generatePrivateKey();
+      const account = privateKeyToAccount(privateKey);
+      const challenge = await ctx.client.authChallenge({
+        address: account.address
+      });
+      const signature = await account.signMessage({
+        message: challenge.message
+      });
+      const verified = await ctx.client.authVerify({
+        address: account.address,
+        nonce: challenge.nonce,
+        signature,
+        message: challenge.message
+      });
+      return {
+        wallet: {
+          address: account.address,
+          privateKey
+        },
+        auth: {
+          token: verified.token,
+          expiresIn: verified.expiresIn
+        },
+        securityNotice: {
+          level: "CRITICAL",
+          message: privateKeySecurityNotice
+        }
+      };
+    });
+  });
+  auth.command("verify").description("Verify SIWE signature and receive JWT").requiredOption("--address <address>", "wallet address").requiredOption("--nonce <nonce>", "challenge nonce").requiredOption("--signature <signature>", "wallet signature").option("--message <text>", "challenge message text").option("--message-file <path>", "file containing challenge message").action(async (options, command) => {
+    await executeOperationCommand(command, cliOperationBindings["auth verify"], async () => {
+      const address = ensureAddress(String(options.address), "--address");
+      const nonce = ensureNonEmpty(String(options.nonce), "--nonce");
+      const signature = ensureNonEmpty(String(options.signature), "--signature");
+      const message = resolveTextInput({
+        inlineValue: options.message,
+        filePath: options.messageFile,
+        fieldName: "message"
+      });
+      return {
+        body: {
+          address,
+          nonce,
+          signature,
+          message: String(message)
+        }
+      };
+    });
+  });
+};
+
+// src/commands/cycles.ts
+var registerCycleCommands = (program) => {
+  const cycles = program.command("cycles").description("Cycle and settlement visibility commands");
+  cycles.command("list").description("List cycles").option("--cursor <offset>", "pagination cursor").option("--limit <number>", "page size").action(async (options, command) => {
+    await executeOperationCommand(command, cliOperationBindings["cycles list"], async () => ({
+      query: {
+        cursor: typeof options.cursor === "string" ? ensureNonEmpty(options.cursor, "--cursor") : void 0,
+        limit: typeof options.limit === "string" ? ensurePositiveInteger(options.limit, "--limit") : void 0
+      }
+    }));
+  });
+  cycles.command("active").description("Get active cycle").action(async (_options, command) => {
+    await executeOperationCommand(command, cliOperationBindings["cycles active"]);
+  });
+  cycles.command("get").description("Get cycle details").requiredOption("--cycle <id>", "cycle id").action(async (options, command) => {
+    await executeOperationCommand(command, cliOperationBindings["cycles get"], async () => ({
+      pathParams: { id: ensureNonEmpty(String(options.cycle), "--cycle") }
+    }));
+  });
+  cycles.command("rewards").description("Get cycle workload and reward references").requiredOption("--cycle <id>", "cycle id").action(async (options, command) => {
+    await executeOperationCommand(command, cliOperationBindings["cycles rewards"], async () => ({
+      pathParams: { id: ensureNonEmpty(String(options.cycle), "--cycle") }
+    }));
+  });
+};
+
+// src/commands/dashboard.ts
+var ensureTrendWindow = (raw) => {
+  const normalized = raw.trim().toLowerCase();
+  if (normalized !== "7d" && normalized !== "30d") {
+    throw new CliValidationError("--window must be 7d or 30d");
+  }
+  return normalized;
+};
+var registerDashboardCommands = (program) => {
+  const dashboard = program.command("dashboard").description("Dashboard read models");
+  dashboard.command("summary").description("Get dashboard summary metrics").option("--tz <timezone>", "IANA timezone, e.g. Asia/Shanghai").action(async (options, command) => {
+    await executeOperationCommand(command, cliOperationBindings["dashboard summary"], async () => ({
+      query: {
+        tz: typeof options.tz === "string" ? ensureIanaTimeZone(options.tz, "--tz") : void 0
+      }
+    }));
+  });
+  dashboard.command("trends").description("Get dashboard trend series").option("--tz <timezone>", "IANA timezone, e.g. Asia/Shanghai").option("--window <window>", "7d|30d").action(async (options, command) => {
+    await executeOperationCommand(command, cliOperationBindings["dashboard trends"], async () => ({
+      query: {
+        tz: typeof options.tz === "string" ? ensureIanaTimeZone(options.tz, "--tz") : void 0,
+        window: typeof options.window === "string" ? ensureTrendWindow(options.window) : void 0
+      }
+    }));
+  });
+};
+
+// src/commands/disputes.ts
+var ensureDisputeStatus = (raw) => {
+  const normalized = raw.trim().toUpperCase();
+  if (normalized !== "OPEN" && normalized !== "RESOLVED_COMPLETED") {
+    throw new CliValidationError("--status must be OPEN|RESOLVED_COMPLETED");
+  }
+  return normalized;
+};
+var registerDisputeCommands = (program) => {
+  const disputes = program.command("disputes").description("Dispute and supervision commands");
+  disputes.command("list").description("List disputes").option("--task <id>", "task id").option("--opener <address>", "opener address").option("--status <status>", "OPEN|RESOLVED_COMPLETED").option("--q <text>", "search by ids/opener/reason").option("--sort <key>", "latest|created").option("--order <order>", "asc|desc").option("--cursor <offset>", "pagination cursor").option("--limit <number>", "page size").action(async (options, command) => {
+    await executeOperationCommand(command, cliOperationBindings["disputes list"], async () => ({
+      query: {
+        taskId: typeof options.task === "string" ? ensureNonEmpty(options.task, "--task") : void 0,
+        opener: typeof options.opener === "string" ? ensureAddress(options.opener, "--opener") : void 0,
+        status: typeof options.status === "string" ? ensureDisputeStatus(options.status) : void 0,
+        q: typeof options.q === "string" ? ensureNonEmpty(options.q, "--q") : void 0,
+        sort: typeof options.sort === "string" ? options.sort.trim().toLowerCase() : void 0,
+        order: typeof options.order === "string" ? options.order.trim().toLowerCase() : void 0,
+        cursor: typeof options.cursor === "string" ? ensureNonEmpty(options.cursor, "--cursor") : void 0,
+        limit: typeof options.limit === "string" ? ensurePositiveInteger(options.limit, "--limit") : void 0
+      }
+    }));
+  });
+  disputes.command("get").description("Get dispute details").requiredOption("--dispute <id>", "dispute id").action(async (options, command) => {
+    await executeOperationCommand(command, cliOperationBindings["disputes get"], async () => ({
+      pathParams: { id: ensureNonEmpty(String(options.dispute), "--dispute") }
+    }));
+  });
+  disputes.command("open").description("Open a dispute").requiredOption("--task <id>", "task id").requiredOption("--submission <id>", "submission id").option("--reason <markdown>", "reason markdown").option("--reason-file <path>", "file containing dispute reason markdown").action(async (options, command) => {
+    await executeBearerOperationCommand(command, cliOperationBindings["disputes open"], async () => {
+      const reasonMd = resolveTextInput({
+        inlineValue: options.reason,
+        filePath: options.reasonFile,
+        fieldName: "reason"
+      });
+      return {
+        body: {
+          taskId: ensureNonEmpty(String(options.task), "--task"),
+          submissionId: ensureNonEmpty(String(options.submission), "--submission"),
+          reasonMd: String(reasonMd)
+        }
+      };
+    });
+  });
+  disputes.command("vote").description("Vote on a dispute").requiredOption("--dispute <id>", "dispute id").requiredOption("--vote <choice>", "COMPLETED or NOT_COMPLETED").action(async (options, command) => {
+    await executeBearerOperationCommand(command, cliOperationBindings["disputes vote"], async () => ({
+      pathParams: { id: ensureNonEmpty(String(options.dispute), "--dispute") },
+      body: {
+        vote: ensureVoteChoice(String(options.vote))
+      }
+    }));
+  });
+};
+
+// src/commands/economy.ts
+var registerEconomyCommands = (program) => {
+  const economy = program.command("economy").description("Runtime economy parameters");
+  economy.command("params").description("Get economy and guardrail parameters").action(async (_options, command) => {
+    await executeOperationCommand(command, cliOperationBindings["economy params"]);
+  });
+};
+
+// src/commands/ledger.ts
+var registerLedgerCommands = (program) => {
+  const ledger = program.command("ledger").description("Ledger commands");
+  ledger.command("get").description("Get ledger balance for an address").requiredOption("--address <address>", "agent address").action(async (options, command) => {
+    await executeOperationCommand(command, cliOperationBindings["ledger get"], async () => ({
+      pathParams: { address: ensureAddress(String(options.address), "--address") }
+    }));
+  });
+};
+
+// src/commands/submissions.ts
+var registerSubmissionCommands = (program) => {
+  const submissions = program.command("submissions").description("Submission query and moderation commands");
+  submissions.command("list").description("List submissions").option("--task <id>", "task id").option("--agent <address>", "submission agent address").option("--status <status>", "SUBMITTED|CONFIRMED|REJECTED").option("--q <text>", "search by id/agent/payload").option("--sort <key>", "latest|created").option("--order <order>", "asc|desc").option("--cursor <cursor>", "pagination cursor").option("--limit <number>", "page size").action(async (options, command) => {
+    await executeOperationCommand(command, cliOperationBindings["submissions list"], async () => ({
+      query: {
+        taskId: typeof options.task === "string" ? ensureNonEmpty(options.task, "--task") : void 0,
+        agent: typeof options.agent === "string" ? ensureAddress(options.agent, "--agent") : void 0,
+        status: typeof options.status === "string" ? options.status.trim().toUpperCase() : void 0,
+        q: typeof options.q === "string" ? ensureNonEmpty(options.q, "--q") : void 0,
+        sort: typeof options.sort === "string" ? options.sort.trim().toLowerCase() : void 0,
+        order: typeof options.order === "string" ? options.order.trim().toLowerCase() : void 0,
+        cursor: typeof options.cursor === "string" ? ensureNonEmpty(options.cursor, "--cursor") : void 0,
+        limit: typeof options.limit === "string" ? ensurePositiveInteger(options.limit, "--limit") : void 0
+      }
+    }));
+  });
+  submissions.command("get").description("Get submission details").requiredOption("--submission <id>", "submission id").action(async (options, command) => {
+    await executeOperationCommand(command, cliOperationBindings["submissions get"], async () => ({
+      pathParams: { id: ensureNonEmpty(String(options.submission), "--submission") }
+    }));
+  });
+  submissions.command("confirm").description("Confirm a submission").requiredOption("--submission <id>", "submission id").action(async (options, command) => {
+    await executeBearerOperationCommand(command, cliOperationBindings["submissions confirm"], async () => ({
+      pathParams: { id: ensureNonEmpty(String(options.submission), "--submission") }
+    }));
+  });
+  submissions.command("reject").description("Reject a submission").requiredOption("--submission <id>", "submission id").action(async (options, command) => {
+    await executeBearerOperationCommand(command, cliOperationBindings["submissions reject"], async () => ({
+      pathParams: { id: ensureNonEmpty(String(options.submission), "--submission") }
+    }));
+  });
+};
+
+// src/commands/system.ts
+var registerSystemCommands = (program) => {
+  const system = program.command("system").description("System and service commands");
+  system.command("health").description("Get API health status").action(async (_options, command) => {
+    await executeOperationCommand(command, cliOperationBindings["system health"]);
+  });
+};
+
+// src/commands/tasks.ts
+var registerTaskCommands = (program) => {
+  const tasks = program.command("tasks").description("Task lifecycle commands");
+  tasks.command("list").description("List tasks").option("--q <text>", "search by id/title/description/criteria/publisher").option("--status <status>", "OPEN|IN_PROGRESS|TERMINATED|CLOSED").option("--publisher <address>", "publisher address").option("--sort <key>", "latest|created|deadline|reward").option("--order <order>", "asc|desc").option("--cursor <offset>", "pagination cursor").option("--limit <number>", "page size").action(async (options, command) => {
+    await executeOperationCommand(command, cliOperationBindings["tasks list"], async () => ({
+      query: {
+        q: typeof options.q === "string" ? ensureNonEmpty(options.q, "--q") : void 0,
+        status: typeof options.status === "string" ? options.status.trim().toUpperCase() : void 0,
+        publisher: typeof options.publisher === "string" ? ensureAddress(options.publisher, "--publisher") : void 0,
+        sort: typeof options.sort === "string" ? options.sort.trim().toLowerCase() : void 0,
+        order: typeof options.order === "string" ? options.order.trim().toLowerCase() : void 0,
+        cursor: typeof options.cursor === "string" ? ensureNonEmpty(options.cursor, "--cursor") : void 0,
+        limit: typeof options.limit === "string" ? ensurePositiveInteger(options.limit, "--limit") : void 0
+      }
+    }));
+  });
+  tasks.command("get").description("Get task details").requiredOption("--task <id>", "task id").action(async (options, command) => {
+    await executeOperationCommand(command, cliOperationBindings["tasks get"], async () => ({
+      pathParams: { id: ensureNonEmpty(String(options.task), "--task") }
+    }));
+  });
+  tasks.command("create").description("Create a task").requiredOption("--title <title>", "task title").option("--desc <markdown>", "task description markdown").option("--desc-file <path>", "file containing task description markdown").option("--criteria <markdown>", "task acceptance criteria markdown").option("--criteria-file <path>", "file containing task acceptance criteria markdown").requiredOption("--deadline <iso>", "deadline in ISO datetime format").requiredOption("--tz <timezone>", "display timezone").requiredOption("--slots <number>", "slot count").requiredOption("--reward <number>", "reward per slot").option("--allow-repeat", "allow repeat completions by same agent").action(async (options, command) => {
+    await executeBearerOperationCommand(command, cliOperationBindings["tasks create"], async () => {
+      const descriptionMd = resolveTextInput({
+        inlineValue: options.desc,
+        filePath: options.descFile,
+        fieldName: "desc"
+      });
+      const acceptanceCriteria = resolveTextInput({
+        inlineValue: options.criteria,
+        filePath: options.criteriaFile,
+        fieldName: "criteria"
+      });
+      return {
+        body: {
+          title: ensureNonEmpty(String(options.title), "--title"),
+          descriptionMd: String(descriptionMd),
+          acceptanceCriteria: String(acceptanceCriteria),
+          deadlineUtc: ensureIsoDate(String(options.deadline), "--deadline"),
+          displayTimezone: ensureIanaTimeZone(String(options.tz), "--tz"),
+          slotsTotal: ensurePositiveInteger(String(options.slots), "--slots"),
+          rewardPerSlot: ensurePositiveInteger(String(options.reward), "--reward"),
+          allowRepeatCompletionsBySameAgent: Boolean(options.allowRepeat)
+        }
+      };
+    });
+  });
+  tasks.command("intend").description("Add intention for a task").requiredOption("--task <id>", "task id").action(async (options, command) => {
+    await executeBearerOperationCommand(command, cliOperationBindings["tasks intend"], async () => ({
+      pathParams: { id: ensureNonEmpty(String(options.task), "--task") }
+    }));
+  });
+  tasks.command("intentions").description("List task intentions").requiredOption("--task <id>", "task id").option("--cursor <token>", "pagination cursor").option("--limit <number>", "page size").action(async (options, command) => {
+    await executeOperationCommand(command, cliOperationBindings["tasks intentions"], async () => ({
+      pathParams: { id: ensureNonEmpty(String(options.task), "--task") },
+      query: {
+        cursor: typeof options.cursor === "string" ? ensureNonEmpty(options.cursor, "--cursor") : void 0,
+        limit: typeof options.limit === "string" ? ensurePositiveInteger(options.limit, "--limit") : void 0
+      }
+    }));
+  });
+  tasks.command("submit").description("Submit task output").requiredOption("--task <id>", "task id").option("--payload <markdown>", "submission markdown payload").option("--payload-file <path>", "file containing submission markdown payload").action(async (options, command) => {
+    await executeBearerOperationCommand(command, cliOperationBindings["tasks submit"], async () => {
+      const payloadMd = resolveTextInput({
+        inlineValue: options.payload,
+        filePath: options.payloadFile,
+        fieldName: "payload"
+      });
+      return {
+        pathParams: { id: ensureNonEmpty(String(options.task), "--task") },
+        body: {
+          payloadMd: String(payloadMd)
+        }
+      };
+    });
+  });
+  tasks.command("terminate").description("Terminate a task").requiredOption("--task <id>", "task id").action(async (options, command) => {
+    await executeBearerOperationCommand(command, cliOperationBindings["tasks terminate"], async () => ({
+      pathParams: { id: ensureNonEmpty(String(options.task), "--task") }
+    }));
+  });
+};
+
+// src/program.ts
+var cliRuntime = loadCliRuntimeConfig();
+var DEFAULT_BASE_URL = cliRuntime.apiBaseUrl;
+var DEFAULT_TOKEN = cliRuntime.token;
+var DEFAULT_ADMIN_KEY = cliRuntime.adminServiceKey;
+var DEFAULT_TIMEOUT_MS2 = cliRuntime.timeoutMs;
+var DEFAULT_RETRIES2 = cliRuntime.retries;
+var GLOBAL_OPTIONS_WITH_VALUE = /* @__PURE__ */ new Set([
+  "--base-url",
+  "--token",
+  "--admin-key",
+  "--timeout-ms",
+  "--retries"
+]);
+var GLOBAL_BOOLEAN_OPTIONS = /* @__PURE__ */ new Set(["--pretty"]);
+var HELP_APPENDIX = `
+Environment variable fallbacks:
+  AGENTRADE_API_BASE_URL
+  AGENTRADE_TOKEN
+  AGENTRADE_ADMIN_SERVICE_KEY
+  AGENTRADE_TIMEOUT_MS
+  AGENTRADE_RETRIES
+
+Output contract:
+  success: stdout JSON
+  failure: stderr JSON with {type,message,httpStatus,apiError,issues,retryable,command}
+
+Exit codes:
+  0 success | 2 validation | 3 config | 4 api | 5 network | 10 unknown
+`;
+var detectCommandFromArgv = (argv) => {
+  const segments = [];
+  const tokens = argv.slice(2);
+  for (let index = 0; index < tokens.length; index += 1) {
+    const token = tokens[index];
+    if (token === "--") {
+      break;
+    }
+    if (token.startsWith("-")) {
+      if (segments.length > 0) {
+        break;
+      }
+      if (GLOBAL_OPTIONS_WITH_VALUE.has(token) && index + 1 < tokens.length) {
+        index += 1;
+        continue;
+      }
+      if ([...GLOBAL_OPTIONS_WITH_VALUE].some((option) => token.startsWith(`${option}=`))) {
+        continue;
+      }
+      if (GLOBAL_BOOLEAN_OPTIONS.has(token)) {
+        continue;
+      }
+      break;
+    }
+    segments.push(token);
+  }
+  return segments.join(" ") || "agentrade";
+};
+var buildProgram = () => {
+  const program = new Command();
+  program.name("agentrade").description("Agentrade CLI for complete agent/admin lifecycle operations").version("0.1.0").option("--base-url <url>", "API base URL", DEFAULT_BASE_URL).option("--token <token>", "bearer token for authenticated routes", DEFAULT_TOKEN).option("--admin-key <key>", "admin service key for admin routes", DEFAULT_ADMIN_KEY).option("--timeout-ms <ms>", "request timeout in milliseconds", DEFAULT_TIMEOUT_MS2).option("--retries <count>", "retry count for network/429/5xx errors", DEFAULT_RETRIES2).option("--pretty", "pretty-print JSON output", false).showHelpAfterError(false).configureOutput({
+    writeErr: () => void 0
+  }).addHelpText("after", HELP_APPENDIX).exitOverride();
+  registerAuthCommands(program);
+  registerSystemCommands(program);
+  registerTaskCommands(program);
+  registerSubmissionCommands(program);
+  registerDisputeCommands(program);
+  registerAgentCommands(program);
+  registerActivityCommands(program);
+  registerDashboardCommands(program);
+  registerLedgerCommands(program);
+  registerCycleCommands(program);
+  registerEconomyCommands(program);
+  registerAdminCommands(program);
+  return program;
+};
+var runCli = async (argv = process.argv) => {
+  const program = buildProgram();
+  try {
+    await program.parseAsync(argv);
+  } catch (error) {
+    if (shouldSuppressCommanderError(error)) {
+      return;
+    }
+    const command = detectCommandFromArgv(argv);
+    const normalized = normalizeCliError(error, command);
+    printErrorJson(normalized.output);
+    process.exit(normalized.exitCode);
+  }
+};
+
+// src/index.ts
+void runCli();