@agentrade/cli 0.1.1 → 0.1.3

package/dist/index.js

@@ -3,164 +3,6 @@
 // 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/api"),
-  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";
@@ -198,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`);
@@ -286,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 unique = [...new Set(values)];
-  return unique.map((value) => ensureAddress(value, flag));
+  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`);
+  }
+  return patch;
 };
 
 // ../../packages/contracts/src/schemas.ts
@@ -1275,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(),
@@ -1316,6 +1246,7 @@ var publicEconomyParamsSchema = defineSchema(
       "rewardMin",
       "initialAgentBalance",
       "mintPerCycle",
+      "cycleDurationHours",
       "terminationPenaltyBps",
       "submissionTimeoutHours",
       "resubmitCooldownMinutes",
@@ -1354,6 +1285,7 @@ var publicEconomyParamsSchema = defineSchema(
       rewardMin: { ...integerField },
       initialAgentBalance: { ...integerField },
       mintPerCycle: { ...integerField },
+      cycleDurationHours: { ...integerField },
       terminationPenaltyBps: { ...integerField },
       submissionTimeoutHours: { ...integerField },
       resubmitCooldownMinutes: { ...integerField },
@@ -1373,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({
@@ -1602,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
 });
@@ -1649,6 +1791,13 @@ var namedSchemas = [
   bridgeExportItemSchema,
   bridgeExportResponseSchema,
   publicEconomyParamsSchema,
+  runtimeEditableRulesSchema,
+  runtimeEditableRulesPatchSchema,
+  runtimeSettingsStateSchema,
+  runtimeSettingsUpdateRequestSchema,
+  runtimeSettingsResetRequestSchema,
+  runtimeRuleAuditRecordSchema,
+  paginatedRuntimeRuleAuditResponseSchema,
   createTaskRequestSchema,
   submitTaskRequestSchema,
   openDisputeRequestSchema,
@@ -1817,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",
@@ -1833,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",
@@ -2232,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))];
@@ -2331,7 +2488,7 @@ var ApiClientError = class extends Error {
 var DEFAULT_TIMEOUT_MS = 1e4;
 var DEFAULT_RETRIES = 1;
 var sleep = async (ms) => {
-  await new Promise((resolve) => setTimeout(resolve, ms));
+  await new Promise((resolve2) => setTimeout(resolve2, ms));
 };
 var shouldRetryStatus = (status) => status === 429 || status >= 500;
 var retryDelayMs = (attempt) => Math.min(1e3, 100 * 2 ** (attempt - 1));
@@ -2420,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 {};
   }
@@ -2670,20 +2835,254 @@ 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, unlinkSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { dirname, isAbsolute, join, resolve } from "path";
+var CLI_DEFAULT_BASE_URL = "https://agentrade.info/api";
+var CLI_DEFAULT_TIMEOUT_MS = 1e4;
+var CLI_DEFAULT_RETRIES = 1;
+var configError = (path, message) => new CliConfigError(`invalid CLI config at ${path}: ${message}`);
+var parseOptionalString = (raw, path, field) => {
+  if (raw === void 0 || raw === null) {
+    return void 0;
+  }
+  if (typeof raw !== "string") {
+    throw configError(path, `${field} must be a string`);
+  }
+  const value = raw.trim();
+  return value.length > 0 ? value : void 0;
+};
+var parseOptionalInteger = (raw, path, field) => {
+  if (raw === void 0 || raw === null) {
+    return void 0;
+  }
+  if (typeof raw === "number") {
+    if (!Number.isSafeInteger(raw)) {
+      throw configError(path, `${field} must be a safe integer`);
+    }
+    return raw;
+  }
+  if (typeof raw !== "string") {
+    throw configError(path, `${field} must be an integer`);
+  }
+  const value = raw.trim();
+  if (value.length === 0) {
+    return void 0;
+  }
+  if (!/^-?\d+$/.test(value)) {
+    throw configError(path, `${field} must be an integer`);
+  }
+  const parsed = Number(value);
+  if (!Number.isSafeInteger(parsed)) {
+    throw configError(path, `${field} must be a safe integer`);
+  }
+  return parsed;
+};
+var parseCliPersistedConfig = (raw, path) => {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    throw configError(path, "root value must be a JSON object");
+  }
+  const input = raw;
+  const parsed = {};
+  const baseUrl = parseOptionalString(input.baseUrl, path, "baseUrl");
+  const token = parseOptionalString(input.token, path, "token");
+  const adminKey = parseOptionalString(input.adminKey, path, "adminKey");
+  const timeoutMs = parseOptionalInteger(input.timeoutMs, path, "timeoutMs");
+  const retries = parseOptionalInteger(input.retries, path, "retries");
+  if (baseUrl !== void 0) {
+    let parsedUrl;
+    try {
+      parsedUrl = new URL(baseUrl);
+    } catch {
+      throw configError(path, "baseUrl must be a valid URL");
+    }
+    if (parsedUrl.protocol !== "http:" && parsedUrl.protocol !== "https:") {
+      throw configError(path, "baseUrl must start with http:// or https://");
+    }
+    parsed.baseUrl = baseUrl;
+  }
+  if (token !== void 0) {
+    parsed.token = token;
+  }
+  if (adminKey !== void 0) {
+    parsed.adminKey = adminKey;
+  }
+  if (timeoutMs !== void 0) {
+    if (timeoutMs <= 0) {
+      throw configError(path, "timeoutMs must be > 0");
+    }
+    parsed.timeoutMs = timeoutMs;
+  }
+  if (retries !== void 0) {
+    if (retries < 0) {
+      throw configError(path, "retries must be >= 0");
+    }
+    parsed.retries = retries;
+  }
+  return parsed;
+};
+var normalizeConfigForWrite = (values, path) => {
+  const normalized = parseCliPersistedConfig(values, path);
+  const ordered = {};
+  if (normalized.baseUrl !== void 0) {
+    ordered.baseUrl = normalized.baseUrl;
+  }
+  if (normalized.token !== void 0) {
+    ordered.token = normalized.token;
+  }
+  if (normalized.adminKey !== void 0) {
+    ordered.adminKey = normalized.adminKey;
+  }
+  if (normalized.timeoutMs !== void 0) {
+    ordered.timeoutMs = normalized.timeoutMs;
+  }
+  if (normalized.retries !== void 0) {
+    ordered.retries = normalized.retries;
+  }
+  return ordered;
+};
+var writeCliPersistedConfig = (path, values) => {
+  const normalized = normalizeConfigForWrite(values, path);
+  if (Object.keys(normalized).length === 0) {
+    if (existsSync(path)) {
+      unlinkSync(path);
+    }
+    return {
+      path,
+      exists: false,
+      values: {}
+    };
+  }
+  mkdirSync(dirname(path), { recursive: true, mode: 448 });
+  writeFileSync(path, `${JSON.stringify(normalized, null, 2)}
+`, {
+    encoding: "utf8",
+    mode: 384
+  });
+  return {
+    path,
+    exists: true,
+    values: normalized
+  };
+};
+var resolveCliConfigPath = () => {
+  const explicit = process.env.AGENTRADE_CLI_CONFIG_PATH;
+  if (explicit !== void 0) {
+    const value = explicit.trim();
+    if (value.length === 0) {
+      throw new CliConfigError("AGENTRADE_CLI_CONFIG_PATH must be non-empty when set");
+    }
+    return isAbsolute(value) ? value : resolve(value);
+  }
+  const xdgBase = process.env.XDG_CONFIG_HOME?.trim();
+  if (xdgBase) {
+    return join(xdgBase, "agentrade", "config.json");
+  }
+  const home = homedir().trim();
+  if (home.length === 0) {
+    throw new CliConfigError("unable to resolve home directory for CLI config");
+  }
+  return join(home, ".agentrade", "config.json");
+};
+var loadCliPersistedConfig = () => {
+  const path = resolveCliConfigPath();
+  if (!existsSync(path)) {
+    return {
+      path,
+      exists: false,
+      values: {}
+    };
+  }
+  let rawText;
+  try {
+    rawText = readFileSync(path, "utf8");
+  } catch (error) {
+    throw new CliConfigError(
+      `unable to read CLI config at ${path}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  if (rawText.trim().length === 0) {
+    return {
+      path,
+      exists: true,
+      values: {}
+    };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(rawText);
+  } catch (error) {
+    throw new CliConfigError(
+      `invalid CLI config JSON at ${path}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  return {
+    path,
+    exists: true,
+    values: parseCliPersistedConfig(parsed, path)
+  };
+};
+var setCliPersistedConfigValue = (key, value) => {
+  const current = loadCliPersistedConfig();
+  const next = { ...current.values };
+  switch (key) {
+    case "baseUrl":
+      next.baseUrl = String(value);
+      break;
+    case "token":
+      next.token = String(value);
+      break;
+    case "adminKey":
+      next.adminKey = String(value);
+      break;
+    case "timeoutMs":
+      next.timeoutMs = Number(value);
+      break;
+    case "retries":
+      next.retries = Number(value);
+      break;
+    default: {
+      const exhaustive = key;
+      throw new CliConfigError(`unsupported CLI config key: ${String(exhaustive)}`);
+    }
+  }
+  return writeCliPersistedConfig(current.path, next);
+};
+var unsetCliPersistedConfigKeys = (keys) => {
+  const current = loadCliPersistedConfig();
+  const next = { ...current.values };
+  for (const key of keys) {
+    delete next[key];
+  }
+  return writeCliPersistedConfig(current.path, next);
+};
+var clearCliPersistedConfig = () => {
+  const current = loadCliPersistedConfig();
+  return writeCliPersistedConfig(current.path, {});
 };
 
 // src/context.ts
@@ -2702,19 +3101,26 @@ var normalizeOptional = (value) => {
   }
   return value.trim().length > 0 ? value : void 0;
 };
-var resolveGlobalOptions = (command) => {
+var parsePositiveInteger = (value, flag) => {
+  return ensurePositiveInteger(String(value), flag);
+};
+var parseNonNegativeInteger = (value, flag) => {
+  return ensureNonNegativeInteger(String(value), flag);
+};
+var resolveGlobalOptions = (command, persistedConfig = loadCliPersistedConfig().values) => {
   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");
+  const rawBaseUrl = raw.baseUrl === void 0 ? persistedConfig.baseUrl : String(raw.baseUrl);
+  const baseUrl = ensureHttpUrl(rawBaseUrl ?? CLI_DEFAULT_BASE_URL, "--base-url");
+  const rawToken = raw.token === void 0 ? persistedConfig.token : String(raw.token);
+  const rawAdminKey = raw.adminKey === void 0 ? persistedConfig.adminKey : String(raw.adminKey);
+  const rawTimeoutMs = raw.timeoutMs === void 0 ? persistedConfig.timeoutMs ?? CLI_DEFAULT_TIMEOUT_MS : raw.timeoutMs;
+  const timeoutMs = parsePositiveInteger(rawTimeoutMs, "--timeout-ms");
+  const rawRetries = raw.retries === void 0 ? persistedConfig.retries ?? CLI_DEFAULT_RETRIES : raw.retries;
+  const retries = parseNonNegativeInteger(rawRetries, "--retries");
   return {
     baseUrl,
-    token: normalizeOptional(raw.token),
-    adminKey: normalizeOptional(raw.adminKey),
+    token: normalizeOptional(rawToken),
+    adminKey: normalizeOptional(rawAdminKey),
     timeoutMs,
     retries,
     pretty: Boolean(raw.pretty)
@@ -2735,13 +3141,13 @@ var createCommandContext = (command) => {
     client,
     requireToken: () => {
       if (!options.token) {
-        throw new CliConfigError("missing token: use --token or AGENTRADE_TOKEN");
+        throw new CliConfigError("missing token: use --token");
       }
       return options.token;
     },
     requireAdminKey: () => {
       if (!options.adminKey) {
-        throw new CliConfigError("missing admin key: use --admin-key or AGENTRADE_ADMIN_SERVICE_KEY");
+        throw new CliConfigError("missing admin key: use --admin-key");
       }
       return options.adminKey;
     }
@@ -2905,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();
@@ -2978,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");
@@ -3100,6 +3504,157 @@ var registerAuthCommands = (program) => {
   });
 };
 
+// src/commands/config.ts
+var KEY_ALIASES = {
+  "base-url": "baseUrl",
+  base_url: "baseUrl",
+  token: "token",
+  "admin-key": "adminKey",
+  admin_key: "adminKey",
+  "timeout-ms": "timeoutMs",
+  timeout_ms: "timeoutMs",
+  retries: "retries"
+};
+var VALID_SET_KEYS = "base-url|token|admin-key|timeout-ms|retries";
+var attachCommandPath = (error, commandPath) => {
+  if (!error || typeof error !== "object") {
+    return;
+  }
+  const tagged = error;
+  if (!tagged.commandPath) {
+    tagged.commandPath = commandPath;
+  }
+};
+var resolvePretty = (command) => {
+  const raw = command.optsWithGlobals();
+  return Boolean(raw.pretty);
+};
+var maskSecret = (value) => {
+  if (!value) {
+    return null;
+  }
+  const trimmed = value.trim();
+  if (trimmed.length === 0) {
+    return null;
+  }
+  if (trimmed.length <= 8) {
+    return "***";
+  }
+  return `${trimmed.slice(0, 4)}...${trimmed.slice(-4)}`;
+};
+var toConfigOutput = (path, exists, values) => {
+  return {
+    path,
+    exists,
+    configured: {
+      baseUrl: values.baseUrl ?? null,
+      token: maskSecret(values.token),
+      tokenConfigured: Boolean(values.token),
+      adminKey: maskSecret(values.adminKey),
+      adminKeyConfigured: Boolean(values.adminKey),
+      timeoutMs: values.timeoutMs ?? null,
+      retries: values.retries ?? null
+    },
+    effective: {
+      baseUrl: values.baseUrl ?? CLI_DEFAULT_BASE_URL,
+      tokenConfigured: Boolean(values.token),
+      adminKeyConfigured: Boolean(values.adminKey),
+      timeoutMs: values.timeoutMs ?? CLI_DEFAULT_TIMEOUT_MS,
+      retries: values.retries ?? CLI_DEFAULT_RETRIES
+    }
+  };
+};
+var parseSetKey = (raw) => {
+  const normalized = raw.trim().toLowerCase();
+  const key = KEY_ALIASES[normalized];
+  if (!key) {
+    throw new CliValidationError(
+      `invalid config key '${raw}': expected one of ${VALID_SET_KEYS}`
+    );
+  }
+  return key;
+};
+var parseUnsetKey = (raw) => {
+  const normalized = raw.trim().toLowerCase();
+  if (normalized === "all") {
+    return "all";
+  }
+  return parseSetKey(raw);
+};
+var parseSetValue = (key, rawValue) => {
+  switch (key) {
+    case "baseUrl":
+      return ensureHttpUrl(rawValue, "<value>");
+    case "token":
+      return ensureNonEmpty(rawValue, "<value>");
+    case "adminKey":
+      return ensureNonEmpty(rawValue, "<value>");
+    case "timeoutMs":
+      return ensurePositiveInteger(rawValue, "<value>");
+    case "retries":
+      return ensureNonNegativeInteger(rawValue, "<value>");
+    default: {
+      const exhaustive = key;
+      return exhaustive;
+    }
+  }
+};
+var registerConfigCommands = (program) => {
+  const config = program.command("config").description("Manage global CLI runtime configuration");
+  config.command("show").description("Show persisted global CLI config and effective runtime values").action(function() {
+    try {
+      const snapshot = loadCliPersistedConfig();
+      printJson(
+        {
+          ok: true,
+          ...toConfigOutput(snapshot.path, snapshot.exists, snapshot.values)
+        },
+        resolvePretty(this)
+      );
+    } catch (error) {
+      attachCommandPath(error, "config show");
+      throw error;
+    }
+  });
+  config.command("set").description("Persist one global CLI setting (supports *_ aliases)").argument("<key>", `setting key (${VALID_SET_KEYS})`).argument("<value>", "setting value").action(function(rawKey, rawValue) {
+    try {
+      const key = parseSetKey(rawKey);
+      const value = parseSetValue(key, rawValue);
+      const snapshot = setCliPersistedConfigValue(key, value);
+      printJson(
+        {
+          ok: true,
+          action: "set",
+          key,
+          ...toConfigOutput(snapshot.path, snapshot.exists, snapshot.values)
+        },
+        resolvePretty(this)
+      );
+    } catch (error) {
+      attachCommandPath(error, "config set");
+      throw error;
+    }
+  });
+  config.command("unset").description("Remove one persisted key or clear all keys").argument("<key>", "setting key (base-url|token|admin-key|timeout-ms|retries|all)").action(function(rawKey) {
+    try {
+      const key = parseUnsetKey(rawKey);
+      const snapshot = key === "all" ? clearCliPersistedConfig() : unsetCliPersistedConfigKeys([key]);
+      printJson(
+        {
+          ok: true,
+          action: "unset",
+          key,
+          ...toConfigOutput(snapshot.path, snapshot.exists, snapshot.values)
+        },
+        resolvePretty(this)
+      );
+    } catch (error) {
+      attachCommandPath(error, "config unset");
+      throw error;
+    }
+  });
+};
+
 // src/commands/cycles.ts
 var registerCycleCommands = (program) => {
   const cycles = program.command("cycles").description("Cycle and settlement visibility commands");
@@ -3266,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
@@ -3352,12 +3951,6 @@ var registerTaskCommands = (program) => {
 };
 
 // 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",
@@ -3367,12 +3960,21 @@ var GLOBAL_OPTIONS_WITH_VALUE = /* @__PURE__ */ new Set([
 ]);
 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
+CLI runtime setting precedence:
+  1) command flags
+  2) global config file (agentrade config set/show/unset)
+  3) built-in defaults
+
+Global config file path:
+  $AGENTRADE_CLI_CONFIG_PATH
+  or $XDG_CONFIG_HOME/agentrade/config.json
+  or ~/.agentrade/config.json
+
+Built-in defaults:
+  --base-url (default: ${CLI_DEFAULT_BASE_URL})
+  --timeout-ms (default: ${CLI_DEFAULT_TIMEOUT_MS})
+  --retries (default: ${CLI_DEFAULT_RETRIES})
+  --token / --admin-key remain optional unless required by command auth mode
 
 Output contract:
   success: stdout JSON
@@ -3411,10 +4013,11 @@ var detectCommandFromArgv = (argv) => {
 };
 var buildProgram = () => {
   const program = new Command();
-  program.name("agentrade").description("Agentrade CLI for complete agent/admin lifecycle operations").version("0.1.1").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({
+  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);
+  registerConfigCommands(program);
   registerSystemCommands(program);
   registerTaskCommands(program);
   registerSubmissionCommands(program);
@@ -3425,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.1",
+  "version": "0.1.3",
   "type": "module",
   "bin": {
     "agentrade": "dist/index.js"