@agentrade/cli 0.1.2 → 0.1.3

package/dist/index.js

@@ -3,91 +3,6 @@
 // src/program.ts
 import { Command } from "commander";
 
-// 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";
@@ -125,12 +40,85 @@ var ActivityEventType = /* @__PURE__ */ ((ActivityEventType2) => {
   ActivityEventType2["TASK_COMPLETED"] = "TASK_COMPLETED";
   ActivityEventType2["DISPUTE_OPENED"] = "DISPUTE_OPENED";
   ActivityEventType2["TASK_TERMINATED"] = "TASK_TERMINATED";
+  ActivityEventType2["ADMIN_AUDIT"] = "ADMIN_AUDIT";
   return ActivityEventType2;
 })(ActivityEventType || {});
 
+// 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/operation-bindings.ts
+var cliOperationBindings = {
+  "activities list": "activitiesListV2",
+  "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",
+  "system metrics": "systemMetricsV2",
+  "system settings get": "systemSettingsGetV2",
+  "system settings history": "systemSettingsHistoryV2",
+  "system settings reset": "systemSettingsResetV2",
+  "system settings update": "systemSettingsUpdateV2",
+  "tasks create": "tasksCreateV2",
+  "tasks get": "tasksGetV2",
+  "tasks intend": "tasksAddIntentionV2",
+  "tasks intentions": "tasksListIntentionsV2",
+  "tasks list": "tasksListV2",
+  "tasks submit": "tasksSubmitV2",
+  "tasks terminate": "tasksTerminateV2"
+};
+
 // 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 RUNTIME_EDITABLE_KEYS = /* @__PURE__ */ new Set([
+  "cycleDurationHours",
+  "mintPerCycle",
+  "taxRateBps",
+  "taskCompletionPublisherWorkload",
+  "taskCompletionWorkerWorkload",
+  "disputeQuorum",
+  "disputeApprovalBps",
+  "terminationPenaltyBps",
+  "submissionTimeoutHours",
+  "resubmitCooldownMinutes",
+  "reputationWeightPublisherBps",
+  "reputationWeightWorkerBps",
+  "reputationWeightSupervisorBps",
+  "scoreWeightReputationBps",
+  "scoreWeightCompletionBps",
+  "scoreWeightQualityBps"
+]);
 var parseInteger = (raw, flag) => {
   if (!/^[-]?\d+$/.test(raw.trim())) {
     throw new CliValidationError(`${flag} must be an integer`);
@@ -213,23 +201,37 @@ var ensureVoteChoice = (raw) => {
   }
   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");
+var ensureRuntimeSettingsApplyTo = (raw, flag = "--apply-to") => {
+  const normalized = raw.trim().toLowerCase();
+  if (normalized !== "current" && normalized !== "next") {
+    throw new CliValidationError(`${flag} must be current or next`);
   }
   return normalized;
 };
-var parseOptionalAddressList = (raw, flag) => {
-  if (!raw || raw.trim().length === 0) {
-    return void 0;
+var ensureRuntimeSettingsPatchJson = (raw, flag = "--patch-json") => {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new CliValidationError(`${flag} must be a valid JSON object`);
   }
-  const values = raw.split(/[\s,]+/).map((item) => item.trim()).filter((item) => item.length > 0);
-  if (values.length === 0) {
-    return void 0;
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new CliValidationError(`${flag} must be a JSON object`);
+  }
+  const patch = {};
+  for (const [key, value] of Object.entries(parsed)) {
+    if (!RUNTIME_EDITABLE_KEYS.has(key)) {
+      throw new CliValidationError(`${flag} contains unsupported key: ${key}`);
+    }
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+      throw new CliValidationError(`${flag}.${key} must be a finite number`);
+    }
+    patch[key] = value;
+  }
+  if (Object.keys(patch).length === 0) {
+    throw new CliValidationError(`${flag} must include at least one editable rule`);
   }
-  const unique = [...new Set(values)];
-  return unique.map((value) => ensureAddress(value, flag));
+  return patch;
 };
 
 // ../../packages/contracts/src/schemas.ts
@@ -1202,6 +1204,7 @@ var publicEconomyParamsSchema = defineSchema(
     rewardMin: z.number().int(),
     initialAgentBalance: z.number().int(),
     mintPerCycle: z.number().int(),
+    cycleDurationHours: z.number().int(),
     terminationPenaltyBps: z.number().int(),
     submissionTimeoutHours: z.number().int(),
     resubmitCooldownMinutes: z.number().int(),
@@ -1243,6 +1246,7 @@ var publicEconomyParamsSchema = defineSchema(
       "rewardMin",
       "initialAgentBalance",
       "mintPerCycle",
+      "cycleDurationHours",
       "terminationPenaltyBps",
       "submissionTimeoutHours",
       "resubmitCooldownMinutes",
@@ -1281,6 +1285,7 @@ var publicEconomyParamsSchema = defineSchema(
       rewardMin: { ...integerField },
       initialAgentBalance: { ...integerField },
       mintPerCycle: { ...integerField },
+      cycleDurationHours: { ...integerField },
       terminationPenaltyBps: { ...integerField },
       submissionTimeoutHours: { ...integerField },
       resubmitCooldownMinutes: { ...integerField },
@@ -1300,6 +1305,212 @@ var publicEconomyParamsSchema = defineSchema(
     }
   }
 );
+var runtimeEditableRulesSchema = defineSchema(
+  "RuntimeEditableRules",
+  z.object({
+    cycleDurationHours: z.number().int(),
+    mintPerCycle: z.number().int(),
+    taxRateBps: z.number().int(),
+    taskCompletionPublisherWorkload: z.number(),
+    taskCompletionWorkerWorkload: z.number(),
+    disputeQuorum: z.number().int(),
+    disputeApprovalBps: z.number().int(),
+    terminationPenaltyBps: z.number().int(),
+    submissionTimeoutHours: z.number().int(),
+    resubmitCooldownMinutes: 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()
+  }),
+  {
+    type: "object",
+    additionalProperties: false,
+    required: [
+      "cycleDurationHours",
+      "mintPerCycle",
+      "taxRateBps",
+      "taskCompletionPublisherWorkload",
+      "taskCompletionWorkerWorkload",
+      "disputeQuorum",
+      "disputeApprovalBps",
+      "terminationPenaltyBps",
+      "submissionTimeoutHours",
+      "resubmitCooldownMinutes",
+      "reputationWeightPublisherBps",
+      "reputationWeightWorkerBps",
+      "reputationWeightSupervisorBps",
+      "scoreWeightReputationBps",
+      "scoreWeightCompletionBps",
+      "scoreWeightQualityBps"
+    ],
+    properties: {
+      cycleDurationHours: { ...integerField },
+      mintPerCycle: { ...integerField },
+      taxRateBps: { ...integerField },
+      taskCompletionPublisherWorkload: { ...numberField },
+      taskCompletionWorkerWorkload: { ...numberField },
+      disputeQuorum: { ...integerField },
+      disputeApprovalBps: { ...integerField },
+      terminationPenaltyBps: { ...integerField },
+      submissionTimeoutHours: { ...integerField },
+      resubmitCooldownMinutes: { ...integerField },
+      reputationWeightPublisherBps: { ...integerField },
+      reputationWeightWorkerBps: { ...integerField },
+      reputationWeightSupervisorBps: { ...integerField },
+      scoreWeightReputationBps: { ...integerField },
+      scoreWeightCompletionBps: { ...integerField },
+      scoreWeightQualityBps: { ...integerField }
+    }
+  }
+);
+var runtimeEditableRulesPatchSchema = defineSchema(
+  "RuntimeEditableRulesPatch",
+  runtimeEditableRulesSchema.schema.partial(),
+  {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+      cycleDurationHours: { ...integerField },
+      mintPerCycle: { ...integerField },
+      taxRateBps: { ...integerField },
+      taskCompletionPublisherWorkload: { ...numberField },
+      taskCompletionWorkerWorkload: { ...numberField },
+      disputeQuorum: { ...integerField },
+      disputeApprovalBps: { ...integerField },
+      terminationPenaltyBps: { ...integerField },
+      submissionTimeoutHours: { ...integerField },
+      resubmitCooldownMinutes: { ...integerField },
+      reputationWeightPublisherBps: { ...integerField },
+      reputationWeightWorkerBps: { ...integerField },
+      reputationWeightSupervisorBps: { ...integerField },
+      scoreWeightReputationBps: { ...integerField },
+      scoreWeightCompletionBps: { ...integerField },
+      scoreWeightQualityBps: { ...integerField }
+    }
+  }
+);
+var runtimeSettingsStateSchema = defineSchema(
+  "RuntimeSettingsState",
+  z.object({
+    currentRules: runtimeEditableRulesSchema.schema,
+    pendingNextPatch: runtimeEditableRulesPatchSchema.schema.nullable(),
+    nextRules: runtimeEditableRulesSchema.schema,
+    updatedAt: isoDateSchema
+  }),
+  {
+    type: "object",
+    additionalProperties: false,
+    required: ["currentRules", "pendingNextPatch", "nextRules", "updatedAt"],
+    properties: {
+      currentRules: schemaRef(runtimeEditableRulesSchema),
+      pendingNextPatch: { ...schemaRef(runtimeEditableRulesPatchSchema), nullable: true },
+      nextRules: schemaRef(runtimeEditableRulesSchema),
+      updatedAt: { ...isoDateField }
+    }
+  }
+);
+var runtimeSettingsUpdateRequestSchema = defineSchema(
+  "RuntimeSettingsUpdateRequest",
+  z.object({
+    applyTo: z.enum(["current", "next"]),
+    patch: runtimeEditableRulesPatchSchema.schema.refine(
+      (value) => Object.keys(value).length > 0,
+      "patch must contain at least one editable rule"
+    ),
+    reason: z.string().trim().min(1).max(1e3).optional()
+  }),
+  {
+    type: "object",
+    additionalProperties: false,
+    required: ["applyTo", "patch"],
+    properties: {
+      applyTo: { type: "string", enum: ["current", "next"] },
+      patch: schemaRef(runtimeEditableRulesPatchSchema),
+      reason: { ...stringField, minLength: 1, maxLength: 1e3 }
+    }
+  }
+);
+var runtimeSettingsResetRequestSchema = defineSchema(
+  "RuntimeSettingsResetRequest",
+  z.object({
+    applyTo: z.enum(["current", "next"]),
+    reason: z.string().trim().min(1).max(1e3).optional()
+  }),
+  {
+    type: "object",
+    additionalProperties: false,
+    required: ["applyTo"],
+    properties: {
+      applyTo: { type: "string", enum: ["current", "next"] },
+      reason: { ...stringField, minLength: 1, maxLength: 1e3 }
+    }
+  }
+);
+var runtimeRuleAuditRecordSchema = defineSchema(
+  "RuntimeRuleAuditRecord",
+  z.object({
+    id: z.string(),
+    eventType: z.enum(["UPDATE", "RESET", "AUTO_APPLY_NEXT"]),
+    applyTo: z.enum(["current", "next"]).nullable(),
+    reason: z.string().nullable(),
+    actor: z.string().nullable(),
+    cycleId: z.string().nullable(),
+    beforeRules: runtimeEditableRulesSchema.schema.nullable(),
+    afterRules: runtimeEditableRulesSchema.schema.nullable(),
+    patch: runtimeEditableRulesPatchSchema.schema.nullable(),
+    pendingNextPatch: runtimeEditableRulesPatchSchema.schema.nullable(),
+    createdAt: isoDateSchema
+  }),
+  {
+    type: "object",
+    additionalProperties: false,
+    required: [
+      "id",
+      "eventType",
+      "applyTo",
+      "reason",
+      "actor",
+      "cycleId",
+      "beforeRules",
+      "afterRules",
+      "patch",
+      "pendingNextPatch",
+      "createdAt"
+    ],
+    properties: {
+      id: { ...stringField },
+      eventType: { type: "string", enum: ["UPDATE", "RESET", "AUTO_APPLY_NEXT"] },
+      applyTo: { type: "string", enum: ["current", "next"], nullable: true },
+      reason: { ...stringField, nullable: true },
+      actor: { ...stringField, nullable: true },
+      cycleId: { ...stringField, nullable: true },
+      beforeRules: { ...schemaRef(runtimeEditableRulesSchema), nullable: true },
+      afterRules: { ...schemaRef(runtimeEditableRulesSchema), nullable: true },
+      patch: { ...schemaRef(runtimeEditableRulesPatchSchema), nullable: true },
+      pendingNextPatch: { ...schemaRef(runtimeEditableRulesPatchSchema), nullable: true },
+      createdAt: { ...isoDateField }
+    }
+  }
+);
+var paginatedRuntimeRuleAuditResponseSchema = defineSchema(
+  "PaginatedRuntimeRuleAuditResponse",
+  z.object({
+    items: z.array(runtimeRuleAuditRecordSchema.schema),
+    nextCursor: z.string().nullable()
+  }),
+  {
+    type: "object",
+    additionalProperties: false,
+    required: ["items", "nextCursor"],
+    properties: {
+      items: { type: "array", items: schemaRef(runtimeRuleAuditRecordSchema) },
+      nextCursor: { type: "string", nullable: true }
+    }
+  }
+);
 var createTaskRequestSchema = defineSchema(
   "CreateTaskRequest",
   z.object({
@@ -1529,6 +1740,10 @@ var cycleListQuerySchemaV2 = z.object({
   cursor: z.string().optional(),
   limit: z.coerce.number().int().min(1).max(100).default(20)
 });
+var runtimeRuleAuditHistoryQuerySchemaV2 = z.object({
+  cursor: z.string().optional(),
+  limit: z.coerce.number().int().min(1).max(100).default(20)
+});
 var idPathSchema = z.object({
   id: nonEmptyStringSchema
 });
@@ -1576,6 +1791,13 @@ var namedSchemas = [
   bridgeExportItemSchema,
   bridgeExportResponseSchema,
   publicEconomyParamsSchema,
+  runtimeEditableRulesSchema,
+  runtimeEditableRulesPatchSchema,
+  runtimeSettingsStateSchema,
+  runtimeSettingsUpdateRequestSchema,
+  runtimeSettingsResetRequestSchema,
+  runtimeRuleAuditRecordSchema,
+  paginatedRuntimeRuleAuditResponseSchema,
   createTaskRequestSchema,
   submitTaskRequestSchema,
   openDisputeRequestSchema,
@@ -1744,6 +1966,7 @@ var dashboardTrendParameters = [
   queryStringParam("window", { type: "string", enum: ["7d", "30d"], default: "7d" }, { en: "Trend window", zh: "\u8D8B\u52BF\u7A97\u53E3" })
 ];
 var cycleListParametersV2 = [queryCursorParam, queryLimitParam];
+var runtimeRuleHistoryParametersV2 = [queryCursorParam, queryLimitParam];
 var apiOperations = [
   defineOperationSpec({
     baseOperationId: "systemHealth",
@@ -1760,13 +1983,63 @@ var apiOperations = [
     baseOperationId: "systemMetrics",
     method: "GET",
     tag: "System",
-    auth: "admin",
+    auth: "bearer",
     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: "systemSettingsGet",
+    method: "GET",
+    tag: "System",
+    auth: "bearer",
+    summary: { en: "Get runtime settings", zh: "\u8BFB\u53D6\u8FD0\u884C\u89C4\u5219\u8BBE\u7F6E" },
+    pathTemplate: "/v2/system/settings",
+    responseSchema: runtimeSettingsStateSchema.schema,
+    responseComponent: runtimeSettingsStateSchema,
+    errorStatuses: [401, 500]
+  }),
+  defineOperationSpec({
+    baseOperationId: "systemSettingsUpdate",
+    method: "PATCH",
+    tag: "System",
+    auth: "bearer_admin",
+    summary: { en: "Update runtime settings", zh: "\u66F4\u65B0\u8FD0\u884C\u89C4\u5219\u8BBE\u7F6E" },
+    pathTemplate: "/v2/system/settings",
+    bodySchema: runtimeSettingsUpdateRequestSchema.schema,
+    requestBodyComponent: runtimeSettingsUpdateRequestSchema,
+    responseSchema: runtimeSettingsStateSchema.schema,
+    responseComponent: runtimeSettingsStateSchema,
+    errorStatuses: [400, 401, 500]
+  }),
+  defineOperationSpec({
+    baseOperationId: "systemSettingsReset",
+    method: "POST",
+    tag: "System",
+    auth: "bearer_admin",
+    summary: { en: "Reset runtime settings", zh: "\u91CD\u7F6E\u8FD0\u884C\u89C4\u5219\u8BBE\u7F6E" },
+    pathTemplate: "/v2/system/settings/reset",
+    bodySchema: runtimeSettingsResetRequestSchema.schema,
+    requestBodyComponent: runtimeSettingsResetRequestSchema,
+    responseSchema: runtimeSettingsStateSchema.schema,
+    responseComponent: runtimeSettingsStateSchema,
+    errorStatuses: [400, 401, 500]
+  }),
+  defineOperationSpec({
+    baseOperationId: "systemSettingsHistory",
+    method: "GET",
+    tag: "System",
+    auth: "bearer",
+    summary: { en: "List runtime settings history", zh: "\u8BFB\u53D6\u8FD0\u884C\u89C4\u5219\u53D8\u66F4\u5386\u53F2" },
+    pathTemplate: "/v2/system/settings/history",
+    querySchema: runtimeRuleAuditHistoryQuerySchemaV2,
+    responseSchema: paginatedRuntimeRuleAuditResponseSchema.schema,
+    responseComponent: paginatedRuntimeRuleAuditResponseSchema,
+    parameters: runtimeRuleHistoryParametersV2,
+    errorStatuses: [401, 500]
+  }),
   defineOperationSpec({
     baseOperationId: "authChallenge",
     method: "POST",
@@ -2159,49 +2432,6 @@ var apiOperations = [
     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))];
@@ -2347,13 +2577,21 @@ var AgentradeApiClient = class {
       }
       return { authorization: `Bearer ${this.token}` };
     }
-    if (auth === "admin") {
+    if (auth === "bearer_admin") {
+      if (!this.token) {
+        throw new ApiClientError("missing bearer token for authenticated request", {
+          apiError: "MISSING_BEARER_TOKEN"
+        });
+      }
       if (!this.adminKey) {
-        throw new ApiClientError("missing admin service key for admin request", {
+        throw new ApiClientError("missing admin service key for admin-authenticated request", {
           apiError: "MISSING_ADMIN_KEY"
         });
       }
-      return { "x-admin-service-key": this.adminKey };
+      return {
+        authorization: `Bearer ${this.token}`,
+        "x-admin-service-key": this.adminKey
+      };
     }
     return {};
   }
@@ -2597,24 +2835,31 @@ var AgentradeApiClient = class {
   getEconomyParams() {
     return this.requestOperation("economyGetParamsV2");
   }
-  closeCurrentCycleAdmin() {
-    return this.requestOperation("adminCloseCycleV2");
+  getRuntimeSettings() {
+    return this.requestOperation("systemSettingsGetV2");
   }
-  overrideDisputeAdmin(disputeId, payload) {
-    return this.requestOperation("adminOverrideDisputeV2", {
-      pathParams: { id: disputeId },
+  updateRuntimeSettings(payload) {
+    return this.requestOperation("systemSettingsUpdateV2", {
       body: payload
     });
   }
-  exportBridgeBatchAdmin(payload = {}) {
-    return this.requestOperation("adminBridgeExportV2", {
+  resetRuntimeSettings(payload) {
+    return this.requestOperation("systemSettingsResetV2", {
       body: payload
     });
   }
+  getRuntimeSettingsHistory(params) {
+    return this.requestOperation(
+      "systemSettingsHistoryV2",
+      {
+        query: params
+      }
+    );
+  }
 };
 
 // src/cli-config.ts
-import { existsSync, mkdirSync, readFileSync as readFileSync2, unlinkSync, writeFileSync } from "fs";
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "fs";
 import { homedir } from "os";
 import { dirname, isAbsolute, join, resolve } from "path";
 var CLI_DEFAULT_BASE_URL = "https://agentrade.info/api";
@@ -2774,7 +3019,7 @@ var loadCliPersistedConfig = () => {
   }
   let rawText;
   try {
-    rawText = readFileSync2(path, "utf8");
+    rawText = readFileSync(path, "utf8");
   } catch (error) {
     throw new CliConfigError(
       `unable to read CLI config at ${path}: ${error instanceof Error ? error.message : String(error)}`
@@ -3066,46 +3311,13 @@ var executeBearerOperationCommand = async (command, operationId, buildInput) =>
 };
 var executeAdminOperationCommand = async (command, operationId, buildInput) => {
   await executeJsonCommand(command, async (ctx) => {
+    ctx.requireToken();
     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();
@@ -3139,6 +3351,37 @@ var registerActivityCommands = (program) => {
   });
 };
 
+// src/text-input.ts
+import { readFileSync as readFileSync2 } from "fs";
+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 = readFileSync2(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;
+};
+
 // src/commands/agents.ts
 var registerAgentCommands = (program) => {
   const agents = program.command("agents").description("Agent profile and stats commands");
@@ -3578,6 +3821,50 @@ var registerSystemCommands = (program) => {
   system.command("health").description("Get API health status").action(async (_options, command) => {
     await executeOperationCommand(command, cliOperationBindings["system health"]);
   });
+  system.command("metrics").description("Get API metrics (token required)").action(async (_options, command) => {
+    await executeBearerOperationCommand(command, cliOperationBindings["system metrics"]);
+  });
+  const settings = system.command("settings").description("Runtime settings commands");
+  settings.command("get").description("Get runtime settings").action(async (_options, command) => {
+    await executeBearerOperationCommand(command, cliOperationBindings["system settings get"]);
+  });
+  settings.command("update").description("Update runtime settings patch").requiredOption("--apply-to <target>", "current or next").requiredOption("--patch-json <json>", "JSON patch object with editable runtime rule fields").option("--reason <reason>", "optional update reason").action(async (options, command) => {
+    await executeAdminOperationCommand(
+      command,
+      cliOperationBindings["system settings update"],
+      async () => ({
+        body: {
+          applyTo: ensureRuntimeSettingsApplyTo(String(options.applyTo), "--apply-to"),
+          patch: ensureRuntimeSettingsPatchJson(String(options.patchJson), "--patch-json"),
+          ...options.reason ? { reason: ensureNonEmpty(String(options.reason), "--reason") } : {}
+        }
+      })
+    );
+  });
+  settings.command("reset").description("Reset runtime settings to environment defaults").requiredOption("--apply-to <target>", "current or next").option("--reason <reason>", "optional reset reason").action(async (options, command) => {
+    await executeAdminOperationCommand(
+      command,
+      cliOperationBindings["system settings reset"],
+      async () => ({
+        body: {
+          applyTo: ensureRuntimeSettingsApplyTo(String(options.applyTo), "--apply-to"),
+          ...options.reason ? { reason: ensureNonEmpty(String(options.reason), "--reason") } : {}
+        }
+      })
+    );
+  });
+  settings.command("history").description("List runtime settings audit history").option("--cursor <cursor>", "pagination cursor").option("--limit <n>", "page size (1-100)").action(async (options, command) => {
+    await executeBearerOperationCommand(
+      command,
+      cliOperationBindings["system settings history"],
+      async () => ({
+        query: {
+          ...options.cursor ? { cursor: ensureNonEmpty(String(options.cursor), "--cursor") } : {},
+          ...options.limit ? { limit: ensurePositiveInteger(String(options.limit), "--limit") } : {}
+        }
+      })
+    );
+  });
 };
 
 // src/commands/tasks.ts
@@ -3726,7 +4013,7 @@ var detectCommandFromArgv = (argv) => {
 };
 var buildProgram = () => {
   const program = new Command();
-  program.name("agentrade").description("Agentrade CLI for complete agent/admin lifecycle operations").version("0.1.2").option("--base-url <url>", "API base URL").option("--token <token>", "bearer token for authenticated routes").option("--admin-key <key>", "admin service key for admin routes").option("--timeout-ms <ms>", "request timeout in milliseconds").option("--retries <count>", "retry count for network/429/5xx errors").option("--pretty", "pretty-print JSON output", false).showHelpAfterError(false).configureOutput({
+  program.name("agentrade").description("Agentrade CLI for complete authenticated lifecycle operations").version("0.1.2").option("--base-url <url>", "API base URL").option("--token <token>", "bearer token for authenticated routes").option("--admin-key <key>", "admin service key for privileged routes").option("--timeout-ms <ms>", "request timeout in milliseconds").option("--retries <count>", "retry count for network/429/5xx errors").option("--pretty", "pretty-print JSON output", false).showHelpAfterError(false).configureOutput({
     writeErr: () => void 0
   }).addHelpText("after", HELP_APPENDIX).exitOverride();
   registerAuthCommands(program);
@@ -3741,7 +4028,6 @@ var buildProgram = () => {
   registerLedgerCommands(program);
   registerCycleCommands(program);
   registerEconomyCommands(program);
-  registerAdminCommands(program);
   return program;
 };
 var runCli = async (argv = process.argv) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentrade/cli",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "type": "module",
   "bin": {
     "agentrade": "dist/index.js"
@@ -11,27 +11,28 @@
   "publishConfig": {
     "access": "public"
   },
+  "scripts": {
+    "clean": "rm -rf dist",
+    "dev": "tsx src/index.ts",
+    "build": "tsup --config tsup.config.ts",
+    "prepublishOnly": "pnpm run build",
+    "test": "tsx --test test/**/*.test.ts",
+    "test:persistence": "tsx --test --test-concurrency=1 test/persistence.stress.test.ts",
+    "lint": "tsc -p tsconfig.json --noEmit"
+  },
   "dependencies": {
     "commander": "^13.1.0",
     "viem": "^2.23.5",
     "zod": "^3.24.2"
   },
   "devDependencies": {
+    "@agentrade/config": "workspace:*",
+    "@agentrade/contracts": "workspace:*",
+    "@agentrade/sdk": "workspace:*",
+    "@agentrade/types": "workspace:*",
     "@types/node": "^22.13.10",
     "tsup": "^8.2.4",
     "tsx": "^4.19.3",
-    "typescript": "^5.7.3",
-    "@agentrade/config": "0.1.0",
-    "@agentrade/sdk": "0.1.0",
-    "@agentrade/contracts": "0.1.0",
-    "@agentrade/types": "0.1.0"
-  },
-  "scripts": {
-    "clean": "rm -rf dist",
-    "dev": "tsx src/index.ts",
-    "build": "tsup --config tsup.config.ts",
-    "test": "tsx --test test/**/*.test.ts",
-    "test:persistence": "tsx --test --test-concurrency=1 test/persistence.stress.test.ts",
-    "lint": "tsc -p tsconfig.json --noEmit"
+    "typescript": "^5.7.3"
   }
-}
+}

package/LICENSE

@@ -1,22 +0,0 @@
-MIT License
-
-Copyright (c) 2026 Agentrade Contributors
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-