@thinkingai/ae-cli 6.0.54 → 6.0.56

package/dist/evaluation-5YT4QLCL.js

@@ -0,0 +1,3714 @@
+import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
+import {
+  EvalApiError,
+  evalDownloadFile,
+  evalRequest,
+  resolveEvaluationHost
+} from "./chunk-X7DRLE62.js";
+import {
+  getCliToken
+} from "./chunk-P7KL7IOH.js";
+import {
+  isAeSandboxRuntime
+} from "./chunk-LMCYSVVA.js";
+import {
+  CliValidationError,
+  externalCliTokenRequestOptions
+} from "./chunk-ZW4VMY5H.js";
+
+// src/core/eval-session.ts
+var SESSION_PATH = "/api/sandbox/agent/evaluation/session";
+async function requestSandboxEvaluationSession(host, cliToken, teProjectId, fetchImpl = fetch) {
+  const url = `${resolveEvaluationHost(host)}/agent${SESSION_PATH}`;
+  const credentialOptions = externalCliTokenRequestOptions(url);
+  const signal = AbortSignal.timeout(3e4);
+  let response;
+  let body;
+  try {
+    response = await fetchImpl(url, {
+      ...credentialOptions,
+      method: "POST",
+      headers: { Accept: "application/json", "Content-Type": "application/json", "cli-token": cliToken },
+      body: JSON.stringify(teProjectId ? { te_project_id: teProjectId } : {}),
+      redirect: "error",
+      signal
+    });
+    try {
+      body = await response.json();
+    } catch (error) {
+      if (signal.aborted) throw error;
+      body = void 0;
+    }
+  } catch {
+    throw new EvalApiError(signal.aborted ? "Evaluation session request timed out." : "Evaluation session request failed; redirects are not allowed.", {
+      code: signal.aborted ? "EVAL_SANDBOX_SESSION_TIMEOUT" : "EVAL_SANDBOX_SESSION_NETWORK_ERROR",
+      httpStatus: 0,
+      hint: "Verify that the AE Host serves the session endpoint directly without redirects."
+    });
+  }
+  if (!response.ok || typeof body?.session_token !== "string" || !body.session_token) {
+    throw new EvalApiError(
+      typeof body?.error === "string" ? body.error : "Unable to obtain an evaluation session from the sandbox gateway.",
+      {
+        code: "EVAL_SANDBOX_SESSION_FAILED",
+        httpStatus: response.status,
+        sensitiveValues: [cliToken, typeof body?.session_token === "string" ? body.session_token : ""],
+        hint: response.status === 400 ? "Set AE_EVAL_TE_PROJECT_ID when the CLI token is authorized for multiple TE projects." : "Verify that the sandbox gateway and Agent Evaluation service are configured."
+      }
+    );
+  }
+  return body.session_token;
+}
+
+// src/commands/evaluation/shared.ts
+var EVAL_API_PREFIX = "/agenteval/api/v1";
+function evalFlags() {
+  return [
+    {
+      name: "endpoint",
+      type: "string",
+      sensitive: true,
+      desc: `Deprecated: must match the current AE Host. Independent endpoint overrides are unsupported; use --host to select the AE Host instead.`
+    }
+  ];
+}
+function resolveEvalBaseUrl(ctx, environment = process.env) {
+  const baseUrl = resolveEvaluationHost(ctx.host());
+  for (const configured of [ctx.str("endpoint").trim(), environment.AE_EVAL_BASE_URL?.trim()]) {
+    if (!configured) continue;
+    const legacyBaseUrl = configured.replace(/\/+$/, "").replace(/(\/agenteval\/api\/v1|\/agenteval)$/, "");
+    if (resolveEvaluationHost(legacyBaseUrl) !== baseUrl) {
+      throw new CliValidationError("Independent evaluation endpoint overrides are unsupported.", {
+        code: "EVAL_ENDPOINT_OVERRIDE_UNSUPPORTED",
+        hint: "Remove --endpoint and AE_EVAL_BASE_URL; select the evaluation AE Host with --host instead."
+      });
+    }
+  }
+  return baseUrl;
+}
+function evalPathId(ctx, name = "id") {
+  const value = ctx.str(name);
+  if (!/^[a-zA-Z0-9_-]+$/.test(value)) {
+    throw new CliValidationError(`--${name} must be a resource ID containing only letters, digits, hyphens, or underscores.`, {
+      code: "EVAL_RESOURCE_ID_INVALID"
+    });
+  }
+  return encodeURIComponent(value);
+}
+function evalHeaders(environment = process.env) {
+  const accessToken = environment.AE_EVAL_ACCESS_TOKEN?.trim();
+  if (!accessToken) {
+    throw new EvalApiError("AE_EVAL_ACCESS_TOKEN is not set.", {
+      code: "EVAL_ACCESS_TOKEN_MISSING",
+      httpStatus: 0,
+      hint: "Export AE_EVAL_ACCESS_TOKEN with an Agent Evaluation platform session token (POST /agenteval/api/v1/auth/session on the platform web console)."
+    });
+  }
+  return { Authorization: `Bearer ${accessToken}` };
+}
+async function resolveEvalHeaders(ctx, environment = process.env) {
+  if (environment.AE_EVAL_ACCESS_TOKEN?.trim()) return evalHeaders(environment);
+  if (!isAeSandboxRuntime()) return evalHeaders(environment);
+  const cliToken = await getCliToken(ctx.host());
+  const sessionToken = await requestSandboxEvaluationSession(
+    ctx.host(),
+    cliToken,
+    environment.AE_EVAL_TE_PROJECT_ID?.trim()
+  );
+  return { Authorization: `Bearer ${sessionToken}` };
+}
+async function evalDownload(ctx, path2, output) {
+  return evalDownloadFile({
+    baseUrl: resolveEvalBaseUrl(ctx),
+    headers: await resolveEvalHeaders(ctx),
+    method: "GET",
+    path: `${EVAL_API_PREFIX}${path2}`
+  }, output);
+}
+async function evalApi(ctx, method, path2, params, body, options = {}) {
+  return evalRequest({
+    baseUrl: resolveEvalBaseUrl(ctx),
+    headers: await resolveEvalHeaders(ctx),
+    method,
+    path: `${EVAL_API_PREFIX}${path2}`,
+    params,
+    body,
+    idempotencyKey: options.idempotencyKey
+  });
+}
+function evalDryRun(ctx, method, path2, params, body, options = {}) {
+  return {
+    method,
+    url: `${resolveEvalBaseUrl(ctx)}${EVAL_API_PREFIX}${path2}`,
+    params,
+    body,
+    ...options.idempotencyKey ? { headers: { "Idempotency-Key": options.idempotencyKey } } : {}
+  };
+}
+function idFlag(desc = "Resource UUID") {
+  return { name: "id", type: "string", required: true, desc };
+}
+function lockVersionFlag(resource) {
+  return {
+    name: "lock-version",
+    type: "number",
+    required: true,
+    min: 0,
+    desc: `Current ${resource} lock_version (optimistic lock); each successful mutation increments it`
+  };
+}
+function idAndLockFlags(idDesc, resource) {
+  return [idFlag(idDesc), lockVersionFlag(resource)];
+}
+
+// src/commands/evaluation/list-datasets.ts
+var PATH = "/datasets";
+function buildParams(ctx) {
+  const params = {};
+  const search = ctx.str("search");
+  if (search) params.search = search;
+  const status = ctx.str("status");
+  if (status) params.status = status;
+  const cursor = ctx.str("cursor");
+  if (cursor) params.cursor = cursor;
+  const pageSize = ctx.optionalNum("page-size");
+  if (pageSize !== void 0) params.page_size = pageSize;
+  return params;
+}
+var listDatasets = {
+  service: "evaluation",
+  command: "+list_datasets",
+  description: "List evaluation datasets via GET /agenteval/api/v1/datasets. Returns a cursor-paginated page of datasets.",
+  flags: [
+    ...evalFlags(),
+    { name: "search", type: "string", desc: "Search text matching dataset name/description" },
+    {
+      name: "status",
+      type: "string",
+      desc: "Filter by dataset status: CREATING | READY | IMPORT_FAILED"
+    },
+    { name: "cursor", type: "string", desc: "Opaque pagination cursor from the previous page" },
+    {
+      name: "page-size",
+      type: "number",
+      min: 1,
+      max: 200,
+      desc: "Page size (1-200, default 50)"
+    }
+  ],
+  risk: "read",
+  dryRun: (ctx) => evalDryRun(ctx, "GET", PATH, buildParams(ctx)),
+  execute: async (ctx) => evalApi(ctx, "GET", PATH, buildParams(ctx))
+};
+
+// src/commands/evaluation/get-dataset.ts
+var PATH2 = "/datasets";
+function pathFor(ctx) {
+  return `${PATH2}/${evalPathId(ctx, "id")}`;
+}
+var getDataset = {
+  service: "evaluation",
+  command: "+get_dataset",
+  description: "Get one evaluation dataset by id via GET /agenteval/api/v1/datasets/{datasetId}.",
+  flags: [...evalFlags(), idFlag("Dataset UUID")],
+  risk: "read",
+  dryRun: (ctx) => evalDryRun(ctx, "GET", pathFor(ctx)),
+  execute: async (ctx) => evalApi(ctx, "GET", pathFor(ctx))
+};
+
+// src/commands/evaluation/create-dataset.ts
+var PATH3 = "/datasets";
+function buildBody(ctx) {
+  const body = { name: ctx.str("name") };
+  const description = ctx.str("description");
+  if (description) body.description = description;
+  return body;
+}
+var createDataset = {
+  service: "evaluation",
+  command: "+create_dataset",
+  description: "Create a blank evaluation dataset via POST /agenteval/api/v1/datasets. Returns the created dataset.",
+  flags: [
+    ...evalFlags(),
+    { name: "name", type: "string", required: true, desc: "Dataset name (1-128 characters)" },
+    { name: "description", type: "string", desc: "Optional dataset description (<=2000 characters)" }
+  ],
+  risk: "write",
+  dryRun: (ctx) => evalDryRun(ctx, "POST", PATH3, void 0, buildBody(ctx)),
+  execute: async (ctx) => evalApi(ctx, "POST", PATH3, void 0, buildBody(ctx))
+};
+
+// src/commands/evaluation/import-dataset.ts
+import { promises as fs } from "fs";
+import * as path from "path";
+var PATH4 = "/datasets/imports";
+async function buildForm(ctx) {
+  const filePath = path.resolve(ctx.str("file"));
+  let content;
+  try {
+    content = await fs.readFile(filePath);
+  } catch {
+    throw new Error(`File not found or unreadable: ${ctx.str("file")}`);
+  }
+  const form = new FormData();
+  form.append("name", ctx.str("name"));
+  const description = ctx.str("description");
+  if (description) form.append("description", description);
+  const profile = ctx.str("profile");
+  if (profile) form.append("profile", profile);
+  form.append("file", new Blob([Uint8Array.from(content)]), path.basename(filePath));
+  return form;
+}
+var importDataset = {
+  service: "evaluation",
+  command: "+import_dataset",
+  description: "Import an evaluation dataset from a local CSV/Excel/JSONL file via POST /agenteval/api/v1/datasets/imports (multipart). Requires an Idempotency-Key; returns 202 with the created dataset and staged file.",
+  flags: [
+    ...evalFlags(),
+    { name: "name", type: "string", required: true, desc: "Dataset name (1-128 characters)" },
+    {
+      name: "file",
+      type: "string",
+      required: true,
+      desc: "Local path to a CSV, Excel, or JSONL file to import"
+    },
+    {
+      name: "profile",
+      type: "string",
+      desc: "Import profile: GENERIC | AGENT_TASK_CASES_V1 (default GENERIC)"
+    },
+    { name: "description", type: "string", desc: "Optional dataset description (<=2000 characters)" },
+    {
+      name: "idempotency-key",
+      type: "string",
+      required: true,
+      hint: "Required. Use a fresh value per import attempt (max 191 chars) sent as the Idempotency-Key header.",
+      desc: "Unique Idempotency-Key header value (1-191 characters)"
+    }
+  ],
+  risk: "write",
+  dryRun: (ctx) => evalDryRun(ctx, "POST", PATH4, void 0, {
+    name: ctx.str("name"),
+    description: ctx.str("description") || void 0,
+    profile: ctx.str("profile") || "GENERIC",
+    file: ctx.str("file"),
+    contentType: "multipart/form-data"
+  }, { idempotencyKey: ctx.str("idempotency-key") }),
+  execute: async (ctx) => {
+    const form = await buildForm(ctx);
+    return evalApi(ctx, "POST", PATH4, void 0, form, {
+      idempotencyKey: ctx.str("idempotency-key")
+    });
+  }
+};
+
+// src/commands/evaluation/dataset-import-status.ts
+var PATH5 = "/datasets";
+function pathFor2(ctx) {
+  return `${PATH5}/${evalPathId(ctx, "id")}/import-status`;
+}
+var datasetImportStatus = {
+  service: "evaluation",
+  command: "+dataset_import_status",
+  description: "Check the asynchronous import pipeline for a dataset via GET /agenteval/api/v1/datasets/{id}/import-status. Poll this after +import_dataset (which returns 202) until status is READY or IMPORT_FAILED; use +dataset_import_errors for failure details.",
+  flags: [...evalFlags(), idFlag("Dataset UUID")],
+  risk: "read",
+  dryRun: (ctx) => evalDryRun(ctx, "GET", pathFor2(ctx)),
+  execute: async (ctx) => evalApi(ctx, "GET", pathFor2(ctx))
+};
+
+// src/commands/evaluation/dataset-import-errors.ts
+var PATH6 = "/datasets";
+function pathFor3(ctx) {
+  return `${PATH6}/${evalPathId(ctx, "id")}/import-errors`;
+}
+var datasetImportErrors = {
+  service: "evaluation",
+  command: "+dataset_import_errors",
+  description: "Fetch row-level errors from a failed dataset import via GET /agenteval/api/v1/datasets/{id}/import-errors. Only meaningful when +dataset_import_status reports IMPORT_FAILED.",
+  flags: [...evalFlags(), idFlag("Dataset UUID")],
+  risk: "read",
+  dryRun: (ctx) => evalDryRun(ctx, "GET", pathFor3(ctx)),
+  execute: async (ctx) => evalApi(ctx, "GET", pathFor3(ctx))
+};
+
+// src/commands/evaluation/update-dataset.ts
+var PATH7 = "/datasets";
+function pathFor4(ctx) {
+  return `${PATH7}/${evalPathId(ctx, "id")}`;
+}
+function buildBody2(ctx) {
+  const body = { name: ctx.str("name"), lock_version: ctx.num("lock-version") };
+  const description = ctx.str("description");
+  if (description) body.description = description;
+  return body;
+}
+var updateDataset = {
+  service: "evaluation",
+  command: "+update_dataset",
+  description: "Rename or re-describe a dataset via PATCH /agenteval/api/v1/datasets/{id}. Requires the current dataset lock_version from +get_dataset and increments it.",
+  flags: [
+    ...evalFlags(),
+    ...idAndLockFlags("Dataset UUID", "dataset"),
+    { name: "name", type: "string", required: true, desc: "Dataset name (1-128 characters)" },
+    { name: "description", type: "string", desc: "Optional dataset description (<=2000 characters)" }
+  ],
+  risk: "write",
+  dryRun: (ctx) => evalDryRun(ctx, "PATCH", pathFor4(ctx), void 0, buildBody2(ctx)),
+  execute: async (ctx) => evalApi(ctx, "PATCH", pathFor4(ctx), void 0, buildBody2(ctx))
+};
+
+// src/commands/evaluation/delete-dataset.ts
+var PATH8 = "/datasets";
+function pathFor5(ctx) {
+  return `${PATH8}/${evalPathId(ctx, "id")}`;
+}
+function buildParams2(ctx) {
+  return { lock_version: ctx.num("lock-version") };
+}
+var deleteDataset = {
+  service: "evaluation",
+  command: "+delete_dataset",
+  description: "Delete a dataset and its cases via DELETE /agenteval/api/v1/datasets/{id}. Runs referencing the dataset keep their frozen snapshot. Requires the current dataset lock_version as a query parameter.",
+  flags: [...evalFlags(), ...idAndLockFlags("Dataset UUID", "dataset")],
+  risk: "high-risk-write",
+  dryRun: (ctx) => evalDryRun(ctx, "DELETE", pathFor5(ctx), buildParams2(ctx)),
+  execute: async (ctx) => evalApi(ctx, "DELETE", pathFor5(ctx), buildParams2(ctx))
+};
+
+// src/commands/evaluation/transfer-dataset-owner.ts
+var PATH9 = "/datasets";
+function pathFor6(ctx) {
+  return `${PATH9}/${evalPathId(ctx, "id")}/transfer-owner`;
+}
+function buildBody3(ctx) {
+  return { owner_user_id: ctx.str("owner-user-id"), lock_version: ctx.num("lock-version") };
+}
+var transferDatasetOwner = {
+  service: "evaluation",
+  command: "+transfer_dataset_owner",
+  description: "Transfer dataset ownership to another user via POST /agenteval/api/v1/datasets/{id}/transfer-owner. Changes resource permissions; requires ADMIN role and the current dataset lock_version.",
+  flags: [
+    ...evalFlags(),
+    ...idAndLockFlags("Dataset UUID", "dataset"),
+    { name: "owner-user-id", type: "string", required: true, desc: "User UUID of the new owner" }
+  ],
+  risk: "high-risk-write",
+  dryRun: (ctx) => evalDryRun(ctx, "POST", pathFor6(ctx), void 0, buildBody3(ctx)),
+  execute: async (ctx) => evalApi(ctx, "POST", pathFor6(ctx), void 0, buildBody3(ctx))
+};
+
+// src/commands/evaluation/list-dataset-fields.ts
+var PATH10 = "/datasets";
+function pathFor7(ctx) {
+  return `${PATH10}/${evalPathId(ctx, "id")}/fields`;
+}
+var listDatasetFields = {
+  service: "evaluation",
+  command: "+list_dataset_fields",
+  description: "List the field schema of a dataset via GET /agenteval/api/v1/datasets/{id}/fields (field_key, data_type, ordinal). Needed to build run field mappings and case data payloads.",
+  flags: [...evalFlags(), idFlag("Dataset UUID")],
+  risk: "read",
+  dryRun: (ctx) => evalDryRun(ctx, "GET", pathFor7(ctx)),
+  execute: async (ctx) => evalApi(ctx, "GET", pathFor7(ctx))
+};
+
+// src/commands/evaluation/create-dataset-field.ts
+var PATH11 = "/datasets";
+function pathFor8(ctx) {
+  return `${PATH11}/${evalPathId(ctx, "id")}/fields`;
+}
+function buildBody4(ctx) {
+  return { display_name: ctx.str("display-name"), data_type: ctx.str("data-type") };
+}
+var createDatasetField = {
+  service: "evaluation",
+  command: "+create_dataset_field",
+  description: "Add a field to a blank dataset via POST /agenteval/api/v1/datasets/{id}/fields. The new field is appended at the end; reorder with +reorder_dataset_fields.",
+  flags: [
+    ...evalFlags(),
+    idFlag("Dataset UUID"),
+    { name: "display-name", type: "string", required: true, desc: "Field display name (1-128 characters); field_key is derived from it" },
+    { name: "data-type", type: "string", required: true, desc: "Field data type: TEXT | NUMBER | BOOLEAN | JSON | DATE | TIME" }
+  ],
+  risk: "write",
+  dryRun: (ctx) => evalDryRun(ctx, "POST", pathFor8(ctx), void 0, buildBody4(ctx)),
+  execute: async (ctx) => evalApi(ctx, "POST", pathFor8(ctx), void 0, buildBody4(ctx))
+};
+
+// src/commands/evaluation/batch-create-dataset-fields.ts
+var PATH12 = "/datasets";
+var DATA_TYPES = /* @__PURE__ */ new Set(["TEXT", "NUMBER", "BOOLEAN", "JSON", "DATE", "TIME"]);
+function pathFor9(ctx) {
+  return `${PATH12}/${evalPathId(ctx, "id")}/fields/batch`;
+}
+function buildBody5(ctx) {
+  const fields = ctx.json("fields-json");
+  if (!Array.isArray(fields) || fields.length < 1 || fields.length > 100) {
+    throw new CliValidationError("--fields-json must be a JSON array containing 1-100 field definitions");
+  }
+  for (const field of fields) {
+    if (field === null || typeof field !== "object" || Array.isArray(field) || typeof field.display_name !== "string" || !field.display_name || String(field.display_name).length > 128 || !DATA_TYPES.has(String(field.data_type))) {
+      throw new CliValidationError(
+        "--fields-json items must contain display_name with 1-128 characters and data_type TEXT | NUMBER | BOOLEAN | JSON | DATE | TIME"
+      );
+    }
+  }
+  return { fields };
+}
+var batchCreateDatasetFields = {
+  service: "evaluation",
+  command: "+batch_create_dataset_fields",
+  description: "Create 1-100 dataset fields atomically via POST /agenteval/api/v1/datasets/{id}/fields/batch. The request succeeds completely or creates no fields.",
+  flags: [
+    ...evalFlags(),
+    idFlag("Dataset UUID"),
+    {
+      name: "fields-json",
+      type: "json",
+      required: true,
+      desc: `JSON array of 1-100 field definitions, e.g. '[{"display_name":"Question","data_type":"TEXT"}]'`
+    }
+  ],
+  risk: "write",
+  dryRun: (ctx) => evalDryRun(ctx, "POST", pathFor9(ctx), void 0, buildBody5(ctx)),
+  execute: async (ctx) => evalApi(ctx, "POST", pathFor9(ctx), void 0, buildBody5(ctx))
+};
+
+// src/commands/evaluation/update-dataset-field.ts
+var PATH13 = "/datasets";
+function pathFor10(ctx) {
+  return `${PATH13}/${evalPathId(ctx, "id")}/fields/${evalPathId(ctx, "field-id")}`;
+}
+function buildBody6(ctx) {
+  const body = { display_name: ctx.str("display-name"), lock_version: ctx.num("lock-version") };
+  const ordinal = ctx.optionalNum("ordinal");
+  if (ordinal !== void 0) body.ordinal = ordinal;
+  return body;
+}
+var updateDatasetField = {
+  service: "evaluation",
+  command: "+update_dataset_field",
+  description: "Rename or move a dataset field via PATCH /agenteval/api/v1/datasets/{id}/fields/{fieldId}. Requires the dataset lock_version from +get_dataset (not a per-field version) and increments it.",
+  flags: [
+    ...evalFlags(),
+    idFlag("Dataset UUID"),
+    { name: "field-id", type: "string", required: true, desc: "Field UUID from +list_dataset_fields" },
+    { name: "display-name", type: "string", required: true, desc: "New field display name (1-128 characters)" },
+    { name: "ordinal", type: "number", min: 0, desc: "New zero-based position of the field" },
+    lockVersionFlag("dataset")
+  ],
+  risk: "write",
+  dryRun: (ctx) => evalDryRun(ctx, "PATCH", pathFor10(ctx), void 0, buildBody6(ctx)),
+  execute: async (ctx) => evalApi(ctx, "PATCH", pathFor10(ctx), void 0, buildBody6(ctx))
+};
+
+// src/commands/evaluation/delete-dataset-field.ts
+var PATH14 = "/datasets";
+function pathFor11(ctx) {
+  return `${PATH14}/${evalPathId(ctx, "id")}/fields/${evalPathId(ctx, "field-id")}`;
+}
+function buildBody7(ctx) {
+  return { lock_version: ctx.num("lock-version") };
+}
+var deleteDatasetField = {
+  service: "evaluation",
+  command: "+delete_dataset_field",
+  description: "Remove a field from a dataset via DELETE /agenteval/api/v1/datasets/{id}/fields/{fieldId}. Case data for the field is dropped. Requires the dataset lock_version.",
+  flags: [
+    ...evalFlags(),
+    idFlag("Dataset UUID"),
+    { name: "field-id", type: "string", required: true, desc: "Field UUID from +list_dataset_fields" },
+    lockVersionFlag("dataset")
+  ],
+  risk: "high-risk-write",
+  dryRun: (ctx) => evalDryRun(ctx, "DELETE", pathFor11(ctx), void 0, buildBody7(ctx)),
+  execute: async (ctx) => evalApi(ctx, "DELETE", pathFor11(ctx), void 0, buildBody7(ctx))
+};
+
+// src/commands/evaluation/reorder-dataset-fields.ts
+var PATH15 = "/datasets";
+function pathFor12(ctx) {
+  return `${PATH15}/${evalPathId(ctx, "id")}/fields/reorder`;
+}
+function buildBody8(ctx) {
+  const fieldIds = ctx.json("field-ids");
+  if (!Array.isArray(fieldIds) || fieldIds.length === 0 || !fieldIds.every((v) => typeof v === "string")) {
+    throw new Error(`--field-ids must be a non-empty JSON array of field UUIDs, e.g. '["<uuid-1>","<uuid-2>"]'`);
+  }
+  return { field_ids: fieldIds, lock_version: ctx.num("lock-version") };
+}
+var reorderDatasetFields = {
+  service: "evaluation",
+  command: "+reorder_dataset_fields",
+  description: "Reorder all fields of a dataset via PUT /agenteval/api/v1/datasets/{id}/fields/reorder. The array must contain every field UUID exactly once, in the desired order. Requires the dataset lock_version.",
+  flags: [
+    ...evalFlags(),
+    ...idAndLockFlags("Dataset UUID", "dataset"),
+    {
+      name: "field-ids",
+      type: "json",
+      required: true,
+      desc: `JSON array of all field UUIDs in the new order, e.g. '["<uuid-1>","<uuid-2>"]'`
+    }
+  ],
+  risk: "write",
+  dryRun: (ctx) => evalDryRun(ctx, "PUT", pathFor12(ctx), void 0, buildBody8(ctx)),
+  execute: async (ctx) => evalApi(ctx, "PUT", pathFor12(ctx), void 0, buildBody8(ctx))
+};
+
+// src/commands/evaluation/list-dataset-cases.ts
+var PATH16 = "/datasets";
+function pathFor13(ctx) {
+  return `${PATH16}/${evalPathId(ctx, "id")}/cases`;
+}
+function buildParams3(ctx) {
+  const params = {};
+  const pageSize = ctx.optionalNum("page-size");
+  if (pageSize !== void 0) params.page_size = pageSize;
+  const cursor = ctx.str("cursor");
+  if (cursor) params.cursor = cursor;
+  return params;
+}
+var listDatasetCases = {
+  service: "evaluation",
+  command: "+list_dataset_cases",
+  description: "List the cases of a dataset with their field data via GET /agenteval/api/v1/datasets/{id}/cases (cursor-paginated). Use +get_dataset_case for one case in full.",
+  flags: [
+    ...evalFlags(),
+    idFlag("Dataset UUID"),
+    { name: "cursor", type: "string", desc: "Pagination cursor from the previous response next_cursor" },
+    { name: "page-size", type: "number", min: 1, max: 200, desc: "Page size (default 50)" }
+  ],
+  risk: "read",
+  dryRun: (ctx) => evalDryRun(ctx, "GET", pathFor13(ctx), buildParams3(ctx)),
+  execute: async (ctx) => evalApi(ctx, "GET", pathFor13(ctx), buildParams3(ctx))
+};
+
+// src/commands/evaluation/get-dataset-case.ts
+var PATH17 = "/datasets";
+function pathFor14(ctx) {
+  return `${PATH17}/${evalPathId(ctx, "id")}/cases/${evalPathId(ctx, "case-id")}`;
+}
+var getDatasetCase = {
+  service: "evaluation",
+  command: "+get_dataset_case",
+  description: "Get one dataset case with its full field data via GET /agenteval/api/v1/datasets/{id}/cases/{caseId}. Find caseId via +list_dataset_cases.",
+  flags: [
+    ...evalFlags(),
+    idFlag("Dataset UUID"),
+    { name: "case-id", type: "string", required: true, desc: "Case UUID from +list_dataset_cases" }
+  ],
+  risk: "read",
+  dryRun: (ctx) => evalDryRun(ctx, "GET", pathFor14(ctx)),
+  execute: async (ctx) => evalApi(ctx, "GET", pathFor14(ctx))
+};
+
+// src/commands/evaluation/create-dataset-case.ts
+var PATH18 = "/datasets";
+function pathFor15(ctx) {
+  return `${PATH18}/${evalPathId(ctx, "id")}/cases`;
+}
+function buildBody9(ctx) {
+  const data = ctx.json("data");
+  if (typeof data !== "object" || data === null || Array.isArray(data)) {
+    throw new Error(`--data must be a JSON object keyed by field_key, e.g. '{"input":"..."}' (see +list_dataset_fields)`);
+  }
+  return { data };
+}
+var createDatasetCase = {
+  service: "evaluation",
+  command: "+create_dataset_case",
+  description: "Append one case to a dataset via POST /agenteval/api/v1/datasets/{id}/cases. The data object is keyed by field_key from +list_dataset_fields.",
+  flags: [
+    ...evalFlags(),
+    idFlag("Dataset UUID"),
+    { name: "data", type: "json", required: true, sensitive: true, desc: `Case data object keyed by field_key, e.g. '{"input":"...","expected":"..."}'` }
+  ],
+  risk: "write",
+  dryRun: (ctx) => evalDryRun(ctx, "POST", pathFor15(ctx), void 0, buildBody9(ctx)),
+  execute: async (ctx) => evalApi(ctx, "POST", pathFor15(ctx), void 0, buildBody9(ctx))
+};
+
+// src/commands/evaluation/batch-create-dataset-cases.ts
+var PATH19 = "/datasets";
+function pathFor16(ctx) {
+  return `${PATH19}/${evalPathId(ctx, "id")}/cases/batch`;
+}
+function buildBody10(ctx) {
+  const cases = ctx.json("cases-json");
+  if (!Array.isArray(cases) || cases.length < 1 || cases.length > 1e3) {
+    throw new CliValidationError("--cases-json must be a JSON array containing 1-1000 case definitions");
+  }
+  for (const item of cases) {
+    const data = item !== null && typeof item === "object" && !Array.isArray(item) ? item.data : void 0;
+    if (data === null || typeof data !== "object" || Array.isArray(data)) {
+      throw new CliValidationError(
+        `--cases-json items must contain a data object keyed by field_key, e.g. '[{"data":{"input":"..."}}]'`
+      );
+    }
+  }
+  return { cases };
+}
+var batchCreateDatasetCases = {
+  service: "evaluation",
+  command: "+batch_create_dataset_cases",
+  description: "Create 1-1000 dataset cases atomically via POST /agenteval/api/v1/datasets/{id}/cases/batch. The request succeeds completely or creates no cases.",
+  flags: [
+    ...evalFlags(),
+    idFlag("Dataset UUID"),
+    {
+      name: "cases-json",
+      type: "json",
+      required: true,
+      sensitive: true,
+      desc: `JSON array of 1-1000 case definitions; each data object is keyed by field_key, e.g. '[{"data":{"input":"..."}}]'`
+    }
+  ],
+  risk: "write",
+  dryRun: (ctx) => evalDryRun(ctx, "POST", pathFor16(ctx), void 0, buildBody10(ctx)),
+  execute: async (ctx) => evalApi(ctx, "POST", pathFor16(ctx), void 0, buildBody10(ctx))
+};
+
+// src/commands/evaluation/update-dataset-case.ts
+var PATH20 = "/datasets";
+function pathFor17(ctx) {
+  return `${PATH20}/${evalPathId(ctx, "id")}/cases/${evalPathId(ctx, "case-id")}`;
+}
+function buildBody11(ctx) {
+  const data = ctx.json("data");
+  if (typeof data !== "object" || data === null || Array.isArray(data)) {
+    throw new Error(`--data must be a JSON object keyed by field_key, e.g. '{"input":"..."}'`);
+  }
+  return { data, lock_version: ctx.num("lock-version") };
+}
+var updateDatasetCase = {
+  service: "evaluation",
+  command: "+update_dataset_case",
+  description: "Replace the field data of one dataset case via PATCH /agenteval/api/v1/datasets/{id}/cases/{caseId}. Requires the case lock_version from +get_dataset_case.",
+  flags: [
+    ...evalFlags(),
+    idFlag("Dataset UUID"),
+    { name: "case-id", type: "string", required: true, desc: "Case UUID from +list_dataset_cases" },
+    { name: "data", type: "json", required: true, sensitive: true, desc: "New case data object keyed by field_key" },
+    lockVersionFlag("case")
+  ],
+  risk: "write",
+  dryRun: (ctx) => evalDryRun(ctx, "PATCH", pathFor17(ctx), void 0, buildBody11(ctx)),
+  execute: async (ctx) => evalApi(ctx, "PATCH", pathFor17(ctx), void 0, buildBody11(ctx))
+};
+
+// src/commands/evaluation/delete-dataset-case.ts
+var PATH21 = "/datasets";
+function pathFor18(ctx) {
+  return `${PATH21}/${evalPathId(ctx, "id")}/cases/${evalPathId(ctx, "case-id")}`;
+}
+function buildBody12(ctx) {
+  return { lock_version: ctx.num("lock-version") };
+}
+var deleteDatasetCase = {
+  service: "evaluation",
+  command: "+delete_dataset_case",
+  description: "Delete one case from a dataset via DELETE /agenteval/api/v1/datasets/{id}/cases/{caseId}. Requires the case lock_version from +get_dataset_case.",
+  flags: [
+    ...evalFlags(),
+    idFlag("Dataset UUID"),
+    { name: "case-id", type: "string", required: true, desc: "Case UUID from +list_dataset_cases" },
+    lockVersionFlag("case")
+  ],
+  risk: "high-risk-write",
+  dryRun: (ctx) => evalDryRun(ctx, "DELETE", pathFor18(ctx), void 0, buildBody12(ctx)),
+  execute: async (ctx) => evalApi(ctx, "DELETE", pathFor18(ctx), void 0, buildBody12(ctx))
+};
+
+// src/commands/evaluation/export-dataset.ts
+var PATH22 = "/datasets";
+function pathFor19(ctx) {
+  return `${PATH22}/${evalPathId(ctx, "id")}/exports`;
+}
+function buildBody13(ctx) {
+  return { format: ctx.str("export-format") };
+}
+var exportDataset = {
+  service: "evaluation",
+  command: "+export_dataset",
+  description: "Export a dataset to a downloadable file via POST /agenteval/api/v1/datasets/{id}/exports. Returns File metadata; fetch the link with +file_download_url.",
+  flags: [
+    ...evalFlags(),
+    idFlag("Dataset UUID"),
+    { name: "export-format", type: "string", required: true, desc: "Export format: csv | jsonl" }
+  ],
+  risk: "write",
+  dryRun: (ctx) => evalDryRun(ctx, "POST", pathFor19(ctx), void 0, buildBody13(ctx)),
+  execute: async (ctx) => evalApi(ctx, "POST", pathFor19(ctx), void 0, buildBody13(ctx))
+};
+
+// src/commands/evaluation/list-dataset-versions.ts
+var PATH23 = "/datasets";
+function pathFor20(ctx) {
+  return `${PATH23}/${evalPathId(ctx, "id")}/versions`;
+}
+var listDatasetVersions = {
+  service: "evaluation",
+  command: "+list_dataset_versions",
+  description: "List published versions of a dataset via GET /agenteval/api/v1/datasets/{id}/versions. Use a version id with +create_run --dataset-version-id; drafts and published versions are distinct assets.",
+  flags: [...evalFlags(), idFlag("Dataset UUID")],
+  risk: "read",
+  dryRun: (ctx) => evalDryRun(ctx, "GET", pathFor20(ctx)),
+  execute: async (ctx) => evalApi(ctx, "GET", pathFor20(ctx))
+};
+
+// src/commands/evaluation/publish-dataset-version.ts
+var PATH24 = "/datasets";
+function pathFor21(ctx) {
+  return `${PATH24}/${evalPathId(ctx, "id")}/versions`;
+}
+var publishDatasetVersion = {
+  service: "evaluation",
+  command: "+publish_dataset_version",
+  description: "Publish an immutable dataset version via POST /agenteval/api/v1/datasets/{id}/versions. Sends {lock_version}. Publishing without changes returns ASSET_VERSION_NO_CHANGES. Published versions can never be overwritten; runs pin them.",
+  flags: [...evalFlags(), ...idAndLockFlags("Dataset UUID", "dataset")],
+  risk: "write",
+  dryRun: (ctx) => evalDryRun(ctx, "POST", pathFor21(ctx), void 0, { lock_version: ctx.num("lock-version") }),
+  execute: async (ctx) => evalApi(ctx, "POST", pathFor21(ctx), void 0, { lock_version: ctx.num("lock-version") })
+};
+
+// src/commands/evaluation/get-dataset-version.ts
+var PATH25 = "/datasets";
+function pathFor22(ctx) {
+  return `${PATH25}/${evalPathId(ctx, "id")}/versions/${evalPathId(ctx, "version-id")}`;
+}
+var getDatasetVersion = {
+  service: "evaluation",
+  command: "+get_dataset_version",
+  description: "Get a published dataset version and its frozen fields via GET /agenteval/api/v1/datasets/{id}/versions/{versionId}.",
+  flags: [
+    ...evalFlags(),
+    idFlag("Dataset UUID"),
+    { name: "version-id", type: "string", required: true, desc: "Published dataset version UUID" }
+  ],
+  risk: "read",
+  dryRun: (ctx) => evalDryRun(ctx, "GET", pathFor22(ctx)),
+  execute: async (ctx) => evalApi(ctx, "GET", pathFor22(ctx))
+};
+
+// src/commands/evaluation/list-dataset-references.ts
+var PATH26 = "/datasets";
+function pathFor23(ctx) {
+  return `${PATH26}/${evalPathId(ctx, "id")}/references`;
+}
+var listDatasetReferences = {
+  service: "evaluation",
+  command: "+list_dataset_references",
+  description: "List runs referencing a dataset via GET /agenteval/api/v1/datasets/{id}/references. Check this before deleting a dataset or making version/publish decisions; runs keep their frozen snapshot even after the dataset is deleted.",
+  flags: [...evalFlags(), idFlag("Dataset UUID")],
+  risk: "read",
+  dryRun: (ctx) => evalDryRun(ctx, "GET", pathFor23(ctx)),
+  execute: async (ctx) => evalApi(ctx, "GET", pathFor23(ctx))
+};
+
+// src/commands/evaluation/list-evaluators.ts
+var PATH27 = "/evaluators";
+function buildParams4(ctx) {
+  const params = {};
+  const search = ctx.str("search");
+  if (search) params.search = search;
+  const cursor = ctx.str("cursor");
+  if (cursor) params.cursor = cursor;
+  const pageSize = ctx.optionalNum("page-size");
+  if (pageSize !== void 0) params.page_size = pageSize;
+  return params;
+}
+var listEvaluators = {
+  service: "evaluation",
+  command: "+list_evaluators",
+  description: "List LLM judge evaluators via GET /agenteval/api/v1/evaluators. Returns a cursor-paginated page.",
+  flags: [
+    ...evalFlags(),
+    { name: "search", type: "string", desc: "Search text matching evaluator name/description" },
+    { name: "cursor", type: "string", desc: "Opaque pagination cursor from the previous page" },
+    { name: "page-size", type: "number", min: 1, max: 200, desc: "Page size (1-200, default 50)" }
+  ],
+  risk: "read",
+  dryRun: (ctx) => evalDryRun(ctx, "GET", PATH27, buildParams4(ctx)),
+  execute: async (ctx) => evalApi(ctx, "GET", PATH27, buildParams4(ctx))
+};
+
+// src/commands/evaluation/get-evaluator.ts
+var PATH28 = "/evaluators";
+function pathFor24(ctx) {
+  return `${PATH28}/${evalPathId(ctx, "id")}`;
+}
+var getEvaluator = {
+  service: "evaluation",
+  command: "+get_evaluator",
+  description: "Get one evaluator by id via GET /agenteval/api/v1/evaluators/{evaluatorId}.",
+  flags: [...evalFlags(), idFlag("Evaluator UUID")],
+  risk: "read",
+  dryRun: (ctx) => evalDryRun(ctx, "GET", pathFor24(ctx)),
+  execute: async (ctx) => evalApi(ctx, "GET", pathFor24(ctx))
+};
+
+// src/commands/evaluation/create-evaluator.ts
+var PATH29 = "/evaluators";
+function buildBody14(ctx) {
+  const body = { name: ctx.str("name") };
+  const description = ctx.str("description");
+  if (description) body.description = description;
+  const category = ctx.str("category");
+  if (category) body.category = category;
+  const prompt = ctx.str("prompt");
+  if (prompt) body.prompt = prompt;
+  const variables = ctx.json("variables");
+  if (variables !== void 0) {
+    if (!Array.isArray(variables) || !variables.every((v) => typeof v === "string")) {
+      throw new Error(`--variables must be a JSON array of strings, e.g. '["input","output"]'`);
+    }
+    body.variables = variables;
+  }
+  const modelConfigId = ctx.str("model-config-id");
+  if (modelConfigId) body.model_config_id = modelConfigId;
+  const templateCode = ctx.str("template-code");
+  if (templateCode) body.template_code = templateCode;
+  const templateLocale = ctx.str("template-locale");
+  if (templateLocale) body.template_locale = templateLocale;
+  return body;
+}
+var createEvaluator = {
+  service: "evaluation",
+  command: "+create_evaluator",
+  description: "Create an LLM judge evaluator via POST /agenteval/api/v1/evaluators. With --model-config-id it is created ACTIVE; without it a draft is created (activate later with +update_evaluator). The prompt references variables with {{name}} placeholders.",
+  flags: [
+    ...evalFlags(),
+    { name: "template-locale", type: "string", pattern: "^(zh|en)$", desc: "Language copied from built-in templates: zh | en (default zh); project templates are unchanged" },
+    { name: "name", type: "string", required: true, desc: "Evaluator name (1-128 characters)" },
+    { name: "description", type: "string", desc: "Optional description (<=2000 characters)" },
+    { name: "category", type: "string", desc: "Optional category label (<=64 characters), e.g. SAFETY" },
+    { name: "prompt", type: "string", desc: "Judge prompt (<=100000 chars) with {{variable}} placeholders matching --variables" },
+    { name: "variables", type: "json", desc: `JSON array of variable names, e.g. '["input","output"]'` },
+    { name: "model-config-id", type: "string", desc: "Model config UUID that powers the judge; omit to create a draft" },
+    { name: "template-code", type: "string", desc: "Optional evaluator template code to initialize from (<=64 chars)" }
+  ],
+  risk: "write",
+  dryRun: (ctx) => evalDryRun(ctx, "POST", PATH29, void 0, buildBody14(ctx)),
+  execute: async (ctx) => evalApi(ctx, "POST", PATH29, void 0, buildBody14(ctx))
+};
+
+// src/commands/evaluation/update-evaluator.ts
+var PATH30 = "/evaluators";
+function pathFor25(ctx) {
+  return `${PATH30}/${evalPathId(ctx, "id")}`;
+}
+function buildBody15(ctx) {
+  const body = {
+    name: ctx.str("name"),
+    model_config_id: ctx.str("model-config-id"),
+    lock_version: ctx.num("lock-version")
+  };
+  const description = ctx.str("description");
+  if (description) body.description = description;
+  const category = ctx.str("category");
+  if (category) body.category = category;
+  const prompt = ctx.str("prompt");
+  if (prompt) body.prompt = prompt;
+  const variables = ctx.json("variables");
+  if (variables !== void 0) {
+    if (!Array.isArray(variables) || !variables.every((v) => typeof v === "string")) {
+      throw new Error(`--variables must be a JSON array of strings, e.g. '["input","output"]'`);
+    }
+    body.variables = variables;
+  }
+  return body;
+}
+var updateEvaluator = {
+  service: "evaluation",
+  command: "+update_evaluator",
+  description: "Update an evaluator via PATCH /agenteval/api/v1/evaluators/{id}. Full-replace semantics: pass every field including unchanged ones; drafts become ACTIVE once a model config is bound. Requires the current evaluator lock_version from +get_evaluator.",
+  flags: [
+    ...evalFlags(),
+    ...idAndLockFlags("Evaluator UUID", "evaluator"),
+    { name: "name", type: "string", required: true, desc: "Evaluator name (1-128 characters)" },
+    { name: "model-config-id", type: "string", required: true, desc: "Model config UUID that powers the judge" },
+    { name: "description", type: "string", desc: "Optional description (<=2000 characters)" },
+    { name: "category", type: "string", desc: "Optional category label (<=64 characters)" },
+    { name: "prompt", type: "string", desc: "Judge prompt (<=100000 chars) with {{variable}} placeholders" },
+    { name: "variables", type: "json", desc: `JSON array of variable names, e.g. '["input","output"]'` }
+  ],
+  risk: "write",
+  dryRun: (ctx) => evalDryRun(ctx, "PATCH", pathFor25(ctx), void 0, buildBody15(ctx)),
+  execute: async (ctx) => evalApi(ctx, "PATCH", pathFor25(ctx), void 0, buildBody15(ctx))
+};
+
+// src/commands/evaluation/delete-evaluator.ts
+var PATH31 = "/evaluators";
+function pathFor26(ctx) {
+  return `${PATH31}/${evalPathId(ctx, "id")}`;
+}
+function buildBody16(ctx) {
+  return { lock_version: ctx.num("lock-version") };
+}
+var deleteEvaluator = {
+  service: "evaluation",
+  command: "+delete_evaluator",
+  description: "Delete an evaluator via DELETE /agenteval/api/v1/evaluators/{id}. Runs that already bound it keep their frozen snapshot. Requires the current evaluator lock_version.",
+  flags: [...evalFlags(), ...idAndLockFlags("Evaluator UUID", "evaluator")],
+  risk: "high-risk-write",
+  dryRun: (ctx) => evalDryRun(ctx, "DELETE", pathFor26(ctx), void 0, buildBody16(ctx)),
+  execute: async (ctx) => evalApi(ctx, "DELETE", pathFor26(ctx), void 0, buildBody16(ctx))
+};
+
+// src/commands/evaluation/transfer-evaluator-owner.ts
+var PATH32 = "/evaluators";
+function pathFor27(ctx) {
+  return `${PATH32}/${evalPathId(ctx, "id")}/transfer-owner`;
+}
+function buildBody17(ctx) {
+  return { owner_user_id: ctx.str("owner-user-id"), lock_version: ctx.num("lock-version") };
+}
+var transferEvaluatorOwner = {
+  service: "evaluation",
+  command: "+transfer_evaluator_owner",
+  description: "Transfer evaluator ownership to another user via POST /agenteval/api/v1/evaluators/{id}/transfer-owner. Changes resource permissions; requires ADMIN role and the current evaluator lock_version.",
+  flags: [
+    ...evalFlags(),
+    ...idAndLockFlags("Evaluator UUID", "evaluator"),
+    { name: "owner-user-id", type: "string", required: true, desc: "User UUID of the new owner" }
+  ],
+  risk: "high-risk-write",
+  dryRun: (ctx) => evalDryRun(ctx, "POST", pathFor27(ctx), void 0, buildBody17(ctx)),
+  execute: async (ctx) => evalApi(ctx, "POST", pathFor27(ctx), void 0, buildBody17(ctx))
+};
+
+// src/commands/evaluation/list-evaluator-templates.ts
+var PATH33 = "/evaluator-templates";
+var listEvaluatorTemplates = {
+  service: "evaluation",
+  command: "+list_evaluator_templates",
+  description: "List evaluator templates via GET /agenteval/api/v1/evaluator-templates. Templates provide ready-made judge prompts; reference one by code when creating evaluators with +create_evaluator.",
+  flags: [...evalFlags(), { name: "locale", type: "string", pattern: "^(zh|en)$", desc: "Built-in template language: zh | en (server default zh); project templates retain their content" }],
+  risk: "read",
+  dryRun: (ctx) => evalDryRun(ctx, "GET", PATH33, { locale: ctx.str("locale") || void 0 }),
+  execute: async (ctx) => evalApi(ctx, "GET", PATH33, { locale: ctx.str("locale") || void 0 })
+};
+
+// src/commands/evaluation/create-evaluator-template.ts
+var PATH34 = "/evaluator-templates";
+function buildBody18(ctx) {
+  const body = {
+    name: ctx.str("name"),
+    category: ctx.str("category"),
+    prompt: ctx.str("prompt")
+  };
+  const description = ctx.str("description");
+  if (description) body.description = description;
+  const variables = ctx.json("variables");
+  if (variables !== void 0) {
+    if (!Array.isArray(variables) || !variables.every((v) => typeof v === "string")) {
+      throw new Error(`--variables must be a JSON array of strings, e.g. '["input","output"]'`);
+    }
+    body.variables = variables;
+  }
+  return body;
+}
+var createEvaluatorTemplate = {
+  service: "evaluation",
+  command: "+create_evaluator_template",
+  description: "Create a project evaluator template via POST /agenteval/api/v1/evaluator-templates. Templates hold reusable judge prompts; users create evaluators from them by template code. Requires ADMIN role.",
+  flags: [
+    ...evalFlags(),
+    { name: "name", type: "string", required: true, desc: "Template name (1-128 characters)" },
+    { name: "category", type: "string", required: true, desc: "Template category (1-64 characters)" },
+    { name: "prompt", type: "string", required: true, desc: "Judge prompt (1-100000 chars) with {{variable}} placeholders" },
+    { name: "description", type: "string", desc: "Optional description (<=2000 characters)" },
+    { name: "variables", type: "json", desc: `JSON array of variable names, e.g. '["input","output"]'` }
+  ],
+  risk: "write",
+  dryRun: (ctx) => evalDryRun(ctx, "POST", PATH34, void 0, buildBody18(ctx)),
+  execute: async (ctx) => evalApi(ctx, "POST", PATH34, void 0, buildBody18(ctx))
+};
+
+// src/commands/evaluation/disable-evaluator-template.ts
+var PATH35 = "/evaluator-templates";
+function pathFor28(ctx) {
+  return `${PATH35}/${evalPathId(ctx, "id")}`;
+}
+var disableEvaluatorTemplate = {
+  service: "evaluation",
+  command: "+disable_evaluator_template",
+  description: "Disable an evaluator template via DELETE /agenteval/api/v1/evaluator-templates/{id}. Disabled templates can no longer be referenced when creating evaluators. Requires ADMIN role.",
+  flags: [...evalFlags(), idFlag("Evaluator template UUID")],
+  risk: "high-risk-write",
+  dryRun: (ctx) => evalDryRun(ctx, "DELETE", pathFor28(ctx)),
+  execute: async (ctx) => evalApi(ctx, "DELETE", pathFor28(ctx))
+};
+
+// src/commands/evaluation/list-evaluator-versions.ts
+var PATH36 = "/evaluators";
+function pathFor29(ctx) {
+  return `${PATH36}/${evalPathId(ctx, "id")}/versions`;
+}
+var listEvaluatorVersions = {
+  service: "evaluation",
+  command: "+list_evaluator_versions",
+  description: "List published versions of an evaluator via GET /agenteval/api/v1/evaluators/{id}/versions. Pin a version id in +select_run_evaluators --evaluator-versions-json; never guess version UUIDs.",
+  flags: [...evalFlags(), idFlag("Evaluator UUID")],
+  risk: "read",
+  dryRun: (ctx) => evalDryRun(ctx, "GET", pathFor29(ctx)),
+  execute: async (ctx) => evalApi(ctx, "GET", pathFor29(ctx))
+};
+
+// src/commands/evaluation/publish-evaluator-version.ts
+var PATH37 = "/evaluators";
+function pathFor30(ctx) {
+  return `${PATH37}/${evalPathId(ctx, "id")}/versions`;
+}
+var publishEvaluatorVersion = {
+  service: "evaluation",
+  command: "+publish_evaluator_version",
+  description: "Publish an immutable evaluator version via POST /agenteval/api/v1/evaluators/{id}/versions. Sends {lock_version}. Publishing without changes returns ASSET_VERSION_NO_CHANGES. Published versions can never be overwritten; runs pin them.",
+  flags: [...evalFlags(), ...idAndLockFlags("Evaluator UUID", "evaluator")],
+  risk: "write",
+  dryRun: (ctx) => evalDryRun(ctx, "POST", pathFor30(ctx), void 0, { lock_version: ctx.num("lock-version") }),
+  execute: async (ctx) => evalApi(ctx, "POST", pathFor30(ctx), void 0, { lock_version: ctx.num("lock-version") })
+};
+
+// src/commands/evaluation/optimize-evaluator-prompt.ts
+var PATH38 = "/evaluators/prompt-optimization";
+function buildBody19(ctx) {
+  return {
+    model_config_id: ctx.str("model-config-id"),
+    prompt: ctx.str("prompt")
+  };
+}
+var optimizeEvaluatorPrompt = {
+  service: "evaluation",
+  command: "+optimize_evaluator_prompt",
+  description: "Generate an optimized evaluator prompt preview via POST /agenteval/api/v1/evaluators/prompt-optimization. Calls the model and consumes quota (not a pure read). Returns a preview only; it never overwrites an existing evaluator until you apply it explicitly via +update_evaluator.",
+  flags: [
+    ...evalFlags(),
+    { name: "model-config-id", type: "string", required: true, desc: "Model config UUID used to run the optimization" },
+    {
+      name: "prompt",
+      type: "string",
+      required: true,
+      sensitive: true,
+      desc: "Current or draft evaluator prompt to optimize (max 100000 chars); redacted from logs"
+    }
+  ],
+  risk: "write",
+  dryRun: (ctx) => evalDryRun(ctx, "POST", PATH38, void 0, buildBody19(ctx)),
+  execute: async (ctx) => evalApi(ctx, "POST", PATH38, void 0, buildBody19(ctx))
+};
+
+// src/commands/evaluation/get-evaluator-health.ts
+var PATH39 = "/evaluators";
+function pathFor31(ctx) {
+  return `${PATH39}/${evalPathId(ctx, "id")}/health`;
+}
+var getEvaluatorHealth = {
+  service: "evaluation",
+  command: "+get_evaluator_health",
+  description: "Get the warning-only reliability summary of an evaluator via GET /agenteval/api/v1/evaluators/{id}/health (status, parse/provider success rates, score distribution collapse, calibration error count).",
+  flags: [...evalFlags(), idFlag("Evaluator UUID")],
+  risk: "read",
+  dryRun: (ctx) => evalDryRun(ctx, "GET", pathFor31(ctx)),
+  execute: async (ctx) => evalApi(ctx, "GET", pathFor31(ctx))
+};
+
+// src/commands/evaluation/list-calibration-suites.ts
+var PATH40 = "/evaluators";
+function pathFor32(ctx) {
+  return `${PATH40}/${evalPathId(ctx, "id")}/calibration-suites`;
+}
+var listCalibrationSuites = {
+  service: "evaluation",
+  command: "+list_calibration_suites",
+  description: "List calibration suites of an evaluator via GET /agenteval/api/v1/evaluators/{id}/calibration-suites. The default suite is the recommended container for Golden Cases; avoid creating extra suites without a reason.",
+  flags: [...evalFlags(), idFlag("Evaluator UUID")],
+  risk: "read",
+  dryRun: (ctx) => evalDryRun(ctx, "GET", pathFor32(ctx)),
+  execute: async (ctx) => evalApi(ctx, "GET", pathFor32(ctx))
+};
+
+// src/commands/evaluation/create-calibration-suite.ts
+var PATH41 = "/evaluators";
+function pathFor33(ctx) {
+  return `${PATH41}/${evalPathId(ctx, "id")}/calibration-suites`;
+}
+function buildBody20(ctx) {
+  const body = { name: ctx.str("name") };
+  const description = ctx.str("description");
+  if (description) body.description = description;
+  return body;
+}
+var createCalibrationSuite = {
+  service: "evaluation",
+  command: "+create_calibration_suite",
+  description: "Create a calibration suite for an evaluator via POST /agenteval/api/v1/evaluators/{id}/calibration-suites. Prefer the evaluator default suite; create explicit suites only when you need a separate Golden Case set.",
+  flags: [
+    ...evalFlags(),
+    idFlag("Evaluator UUID"),
+    { name: "name", type: "string", required: true, desc: "Suite name (1-128 characters)" },
+    { name: "description", type: "string", desc: "Optional suite description (max 2000 chars)" }
+  ],
+  risk: "write",
+  dryRun: (ctx) => evalDryRun(ctx, "POST", pathFor33(ctx), void 0, buildBody20(ctx)),
+  execute: async (ctx) => evalApi(ctx, "POST", pathFor33(ctx), void 0, buildBody20(ctx))
+};
+
+// src/commands/evaluation/list-calibration-cases.ts
+var PATH42 = "/calibration-suites";
+function pathFor34(ctx) {
+  return `${PATH42}/${evalPathId(ctx, "id")}/cases`;
+}
+var listCalibrationCases = {
+  service: "evaluation",
+  command: "+list_calibration_cases",
+  description: "List active Golden Cases of a calibration suite via GET /agenteval/api/v1/calibration-suites/{id}/cases.",
+  flags: [...evalFlags(), idFlag("Calibration suite UUID")],
+  risk: "read",
+  dryRun: (ctx) => evalDryRun(ctx, "GET", pathFor34(ctx)),
+  execute: async (ctx) => evalApi(ctx, "GET", pathFor34(ctx))
+};
+
+// src/commands/evaluation/create-calibration-case.ts
+var PATH43 = "/calibration-suites";
+function pathFor35(ctx) {
+  return `${PATH43}/${evalPathId(ctx, "id")}/cases`;
+}
+function buildBody21(ctx) {
+  const variables = ctx.json("variables-json");
+  if (variables === null || typeof variables !== "object" || Array.isArray(variables)) {
+    throw new Error("--variables-json must be a JSON object of template variables");
+  }
+  const tags = ctx.json("tags-json");
+  if (!Array.isArray(tags) || tags.length > 20 || !tags.every((v) => typeof v === "string")) {
+    throw new Error("--tags-json must be a JSON array of at most 20 strings");
+  }
+  return {
+    variables,
+    expected_score: ctx.num("expected-score"),
+    tolerance: ctx.num("tolerance"),
+    tags
+  };
+}
+var createCalibrationCase = {
+  service: "evaluation",
+  command: "+create_calibration_case",
+  description: "Add a Golden Case to a calibration suite via POST /agenteval/api/v1/calibration-suites/{id}/cases. The case stores variables, an expected score (0-1) and a tolerance (0-1) used to calibrate the evaluator.",
+  flags: [
+    ...evalFlags(),
+    idFlag("Calibration suite UUID"),
+    {
+      name: "variables-json",
+      type: "json",
+      required: true,
+      desc: "JSON object of template variables rendered into the evaluator template input"
+    },
+    { name: "expected-score", type: "number", required: true, min: 0, max: 1, desc: "Expected evaluator score (0-1)" },
+    { name: "tolerance", type: "number", required: true, min: 0, max: 1, desc: "Allowed deviation from the expected score (0-1)" },
+    {
+      name: "tags-json",
+      type: "json",
+      required: true,
+      desc: `JSON array of at most 20 tags (each max 64 chars), e.g. '["golden","regression"]'`
+    }
+  ],
+  risk: "write",
+  dryRun: (ctx) => evalDryRun(ctx, "POST", pathFor35(ctx), void 0, buildBody21(ctx)),
+  execute: async (ctx) => evalApi(ctx, "POST", pathFor35(ctx), void 0, buildBody21(ctx))
+};
+
+// src/commands/evaluation/delete-calibration-case.ts
+var PATH44 = "/calibration-cases";
+function pathFor36(ctx) {
+  return `${PATH44}/${evalPathId(ctx, "id")}`;
+}
+var deleteCalibrationCase = {
+  service: "evaluation",
+  command: "+delete_calibration_case",
+  description: "Delete a Golden Case via DELETE /agenteval/api/v1/calibration-cases/{id}. Sends {lock_version} in the body; get the current lock_version from +list_calibration_cases.",
+  flags: [...evalFlags(), ...idAndLockFlags("Calibration case UUID", "calibration case")],
+  risk: "high-risk-write",
+  dryRun: (ctx) => evalDryRun(ctx, "DELETE", pathFor36(ctx), void 0, { lock_version: ctx.num("lock-version") }),
+  execute: async (ctx) => evalApi(ctx, "DELETE", pathFor36(ctx), void 0, { lock_version: ctx.num("lock-version") })
+};
+
+// src/commands/evaluation/start-calibration-run.ts
+var PATH45 = "/calibration-suites";
+function pathFor37(ctx) {
+  return `${PATH45}/${evalPathId(ctx, "id")}/runs`;
+}
+var startCalibrationRun = {
+  service: "evaluation",
+  command: "+start_calibration_run",
+  description: "Queue a calibration run for a suite via POST /agenteval/api/v1/calibration-suites/{id}/runs. Sends no request body; returns the queued calibration run. Poll +get_calibration_run, then +list_calibration_results.",
+  flags: [...evalFlags(), idFlag("Calibration suite UUID")],
+  risk: "write",
+  dryRun: (ctx) => evalDryRun(ctx, "POST", pathFor37(ctx)),
+  execute: async (ctx) => evalApi(ctx, "POST", pathFor37(ctx))
+};
+
+// src/commands/evaluation/get-calibration-run.ts
+var PATH46 = "/calibration-runs";
+function pathFor38(ctx) {
+  return `${PATH46}/${evalPathId(ctx, "id")}`;
+}
+var getCalibrationRun = {
+  service: "evaluation",
+  command: "+get_calibration_run",
+  description: "Get a calibration run via GET /agenteval/api/v1/calibration-runs/{id}. Poll until terminal status, then fetch +list_calibration_results.",
+  flags: [...evalFlags(), idFlag("Calibration run UUID")],
+  risk: "read",
+  dryRun: (ctx) => evalDryRun(ctx, "GET", pathFor38(ctx)),
+  execute: async (ctx) => evalApi(ctx, "GET", pathFor38(ctx))
+};
+
+// src/commands/evaluation/list-calibration-results.ts
+var PATH47 = "/calibration-runs";
+function pathFor39(ctx) {
+  return `${PATH47}/${evalPathId(ctx, "id")}/results`;
+}
+var listCalibrationResults = {
+  service: "evaluation",
+  command: "+list_calibration_results",
+  description: "List per-case calibration results of a calibration run via GET /agenteval/api/v1/calibration-runs/{id}/results. Each result compares the evaluator score with the Golden Case expected score and tolerance.",
+  flags: [...evalFlags(), idFlag("Calibration run UUID")],
+  risk: "read",
+  dryRun: (ctx) => evalDryRun(ctx, "GET", pathFor39(ctx)),
+  execute: async (ctx) => evalApi(ctx, "GET", pathFor39(ctx))
+};
+
+// src/commands/evaluation/list-runs.ts
+var PATH48 = "/evaluation-runs";
+function buildParams5(ctx) {
+  const params = {};
+  const search = ctx.str("search");
+  if (search) params.search = search;
+  const status = ctx.str("status");
+  if (status) params.status = status;
+  const cursor = ctx.str("cursor");
+  if (cursor) params.cursor = cursor;
+  const limit = ctx.optionalNum("limit");
+  if (limit !== void 0) params.limit = limit;
+  return params;
+}
+var listRuns = {
+  service: "evaluation",
+  command: "+list_runs",
+  description: "List evaluation runs via GET /agenteval/api/v1/evaluation-runs. Returns a cursor-paginated page with snapshot names, counts, and average score.",
+  flags: [
+    ...evalFlags(),
+    { name: "search", type: "string", desc: "Search text matching run name/description" },
+    {
+      name: "status",
+      type: "string",
+      desc: "Filter by run status: DRAFT | QUEUED | RUNNING | CANCELLING | COMPLETED | PARTIALLY_FAILED | FAILED | CANCELLED"
+    },
+    { name: "cursor", type: "string", desc: "Opaque pagination cursor from the previous page" },
+    { name: "limit", type: "number", min: 1, max: 200, desc: "Page size (1-200, default 50)" }
+  ],
+  risk: "read",
+  dryRun: (ctx) => evalDryRun(ctx, "GET", PATH48, buildParams5(ctx)),
+  execute: async (ctx) => evalApi(ctx, "GET", PATH48, buildParams5(ctx))
+};
+
+// src/commands/evaluation/get-run.ts
+var PATH49 = "/evaluation-runs";
+function pathFor40(ctx) {
+  return `${PATH49}/${evalPathId(ctx, "id")}`;
+}
+var getRun = {
+  service: "evaluation",
+  command: "+get_run",
+  description: "Get one evaluation run by id via GET /agenteval/api/v1/evaluation-runs/{runId}, including its frozen snapshot summary.",
+  flags: [...evalFlags(), idFlag("Run UUID")],
+  risk: "read",
+  dryRun: (ctx) => evalDryRun(ctx, "GET", pathFor40(ctx)),
+  execute: async (ctx) => evalApi(ctx, "GET", pathFor40(ctx))
+};
+
+// src/commands/evaluation/create-run.ts
+var PATH50 = "/evaluation-runs";
+var EXECUTION_MODES = ["LIVE_AGENT", "PRESET_RESULT"];
+function buildBody22(ctx) {
+  const body = { name: ctx.str("name") };
+  const description = ctx.str("description");
+  if (description) body.description = description;
+  const datasetId = ctx.str("dataset-id");
+  if (datasetId) body.dataset_id = datasetId;
+  const datasetVersionId = ctx.str("dataset-version-id");
+  if (datasetVersionId) body.dataset_version_id = datasetVersionId;
+  const subjectType = ctx.str("subject-type");
+  if (subjectType) body.subject_type = subjectType;
+  const executionMode = ctx.str("execution-mode") || "LIVE_AGENT";
+  if (!EXECUTION_MODES.includes(executionMode)) {
+    throw new Error("--execution-mode must be one of LIVE_AGENT | PRESET_RESULT");
+  }
+  const agentConfigId = ctx.str("agent-config-id");
+  const modelConfigId = ctx.str("model-config-id");
+  if (executionMode === "PRESET_RESULT" && (agentConfigId || modelConfigId)) {
+    throw new Error("--agent-config-id / --model-config-id are not allowed with --execution-mode PRESET_RESULT");
+  }
+  if (agentConfigId) body.agent_config_id = agentConfigId;
+  if (modelConfigId) body.model_config_id = modelConfigId;
+  body.execution_mode = executionMode;
+  const reportToTe = ctx.json("report-to-te");
+  if (reportToTe !== void 0) body.report_to_te = Boolean(reportToTe);
+  const fieldMapping = ctx.json("field-mapping-json");
+  if (fieldMapping !== void 0) body.field_mapping_json = fieldMapping;
+  const resultFilterFields = ctx.json("result-filter-fields-json");
+  if (resultFilterFields !== void 0) body.result_filter_fields_json = resultFilterFields;
+  const passThreshold = ctx.optionalNum("pass-threshold");
+  if (passThreshold !== void 0) body.pass_threshold = passThreshold;
+  const caseSampleSize = ctx.optionalNum("case-sample-size");
+  if (caseSampleSize !== void 0) {
+    if (!Number.isInteger(caseSampleSize) || caseSampleSize < 1 || caseSampleSize > 1e3) {
+      throw new CliValidationError("--case-sample-size must be an integer between 1 and 1000");
+    }
+    body.case_sample_size = caseSampleSize;
+  }
+  const idempotencyKey = ctx.str("idempotency-key");
+  if (idempotencyKey) body.idempotency_key = idempotencyKey;
+  return body;
+}
+var createRun = {
+  service: "evaluation",
+  command: "+create_run",
+  description: "Create a draft evaluation run via POST /agenteval/api/v1/evaluation-runs. Returns the draft with lock_version. The run must target a published dataset version (--dataset-version-id from +list_dataset_versions). Configure evaluators, field mapping, and validation before starting.",
+  flags: [
+    ...evalFlags(),
+    { name: "name", type: "string", required: true, desc: "Run name (1-128 characters)" },
+    { name: "description", type: "string", desc: "Optional run description (<=2000 characters)" },
+    { name: "dataset-id", type: "string", desc: "Dataset UUID this run evaluates against" },
+    {
+      name: "dataset-version-id",
+      type: "string",
+      desc: "Published dataset version UUID (from +list_dataset_versions); required for PRESET_RESULT and recommended for every run"
+    },
+    {
+      name: "execution-mode",
+      type: "string",
+      desc: "LIVE_AGENT (default) sends the case to the Agent/Model; PRESET_RESULT scores fields already stored in the selected published dataset version"
+    },
+    {
+      name: "subject-type",
+      type: "string",
+      desc: "Subject under test: AGENT | MODEL (default AGENT); only meaningful for LIVE_AGENT"
+    },
+    { name: "agent-config-id", type: "string", desc: "Agent config UUID (LIVE_AGENT with subject_type=AGENT)" },
+    { name: "model-config-id", type: "string", desc: "Model config UUID (LIVE_AGENT with subject_type=MODEL)" },
+    {
+      name: "report-to-te",
+      type: "boolean",
+      desc: "When true, report an agent_eval_run_completed event to ThinkingData at terminal status"
+    },
+    {
+      name: "field-mapping-json",
+      type: "json",
+      desc: "FieldMapping JSON (schema_version/agent/evaluators); V6 adds AGENT_EXECUTION_TRACE and AGENT_TOOL_CALLS for LIVE_AGENT Agent process scoring"
+    },
+    {
+      name: "result-filter-fields-json",
+      type: "json",
+      desc: "ResultFilterFields JSON (schema_version/fields, max 5)"
+    },
+    { name: "pass-threshold", type: "number", min: 0, max: 1, desc: "Optional pass threshold (0-1)" },
+    {
+      name: "case-sample-size",
+      type: "number",
+      min: 1,
+      max: 1e3,
+      desc: "Randomly sample this many dataset cases when the run starts (1-1000); omit to run all cases"
+    },
+    {
+      name: "idempotency-key",
+      type: "string",
+      desc: "Optional Idempotency-Key value (max 128 chars) for duplicate-create protection"
+    }
+  ],
+  risk: "write",
+  dryRun: (ctx) => evalDryRun(ctx, "POST", PATH50, void 0, buildBody22(ctx)),
+  execute: async (ctx) => evalApi(ctx, "POST", PATH50, void 0, buildBody22(ctx))
+};
+
+// src/commands/evaluation/update-run.ts
+var PATH51 = "/evaluation-runs";
+var EXECUTION_MODES2 = ["LIVE_AGENT", "PRESET_RESULT"];
+function pathFor41(ctx) {
+  return `${PATH51}/${evalPathId(ctx, "id")}`;
+}
+function buildBody23(ctx) {
+  const body = { name: ctx.str("name"), lock_version: ctx.num("lock-version") };
+  const description = ctx.str("description");
+  if (description) body.description = description;
+  const datasetId = ctx.str("dataset-id");
+  if (datasetId) body.dataset_id = datasetId;
+  const datasetVersionId = ctx.str("dataset-version-id");
+  if (datasetVersionId) body.dataset_version_id = datasetVersionId;
+  const subjectType = ctx.str("subject-type");
+  if (subjectType) body.subject_type = subjectType;
+  const executionMode = ctx.str("execution-mode") || "LIVE_AGENT";
+  if (!EXECUTION_MODES2.includes(executionMode)) {
+    throw new Error("--execution-mode must be one of LIVE_AGENT | PRESET_RESULT");
+  }
+  const agentConfigId = ctx.str("agent-config-id");
+  const modelConfigId = ctx.str("model-config-id");
+  if (executionMode === "PRESET_RESULT" && (agentConfigId || modelConfigId)) {
+    throw new Error("--agent-config-id / --model-config-id are not allowed with --execution-mode PRESET_RESULT");
+  }
+  if (agentConfigId) body.agent_config_id = agentConfigId;
+  if (modelConfigId) body.model_config_id = modelConfigId;
+  body.execution_mode = executionMode;
+  const fieldMapping = ctx.json("field-mapping-json");
+  if (fieldMapping !== void 0) body.field_mapping_json = fieldMapping;
+  const resultFilterFields = ctx.json("result-filter-fields-json");
+  if (resultFilterFields !== void 0) body.result_filter_fields_json = resultFilterFields;
+  const passThreshold = ctx.optionalNum("pass-threshold");
+  if (passThreshold !== void 0) body.pass_threshold = passThreshold;
+  const caseSampleSize = ctx.optionalNum("case-sample-size");
+  if (caseSampleSize !== void 0) {
+    if (!Number.isInteger(caseSampleSize) || caseSampleSize < 1 || caseSampleSize > 1e3) {
+      throw new CliValidationError("--case-sample-size must be an integer between 1 and 1000");
+    }
+    body.case_sample_size = caseSampleSize;
+  }
+  return body;
+}
+var updateRun = {
+  service: "evaluation",
+  command: "+update_run",
+  description: "Update a draft evaluation run via PATCH /agenteval/api/v1/evaluation-runs/{runId}. Full-replace semantics for provided fields; requires the current lock_version from +get_run and increments it. Runs must target a published dataset version (--dataset-version-id from +list_dataset_versions).",
+  flags: [
+    ...evalFlags(),
+    idFlag("Run UUID"),
+    { name: "name", type: "string", required: true, desc: "Run name (1-128 characters)" },
+    { name: "description", type: "string", desc: "Optional run description (<=2000 characters)" },
+    { name: "dataset-id", type: "string", desc: "Dataset UUID this run evaluates against" },
+    {
+      name: "dataset-version-id",
+      type: "string",
+      desc: "Published dataset version UUID (from +list_dataset_versions); required for PRESET_RESULT and recommended for every run"
+    },
+    {
+      name: "execution-mode",
+      type: "string",
+      desc: "LIVE_AGENT (default) sends the case to the Agent/Model; PRESET_RESULT scores fields already stored in the selected published dataset version"
+    },
+    { name: "subject-type", type: "string", desc: "Subject under test: AGENT | MODEL" },
+    { name: "agent-config-id", type: "string", desc: "Agent config UUID (LIVE_AGENT with subject_type=AGENT)" },
+    { name: "model-config-id", type: "string", desc: "Model config UUID (LIVE_AGENT with subject_type=MODEL)" },
+    { name: "field-mapping-json", type: "json", desc: "FieldMapping JSON (schema_version/agent/evaluators); V6 adds AGENT_EXECUTION_TRACE and AGENT_TOOL_CALLS for LIVE_AGENT Agent process scoring" },
+    { name: "result-filter-fields-json", type: "json", desc: "ResultFilterFields JSON (schema_version/fields, max 5)" },
+    { name: "pass-threshold", type: "number", min: 0, max: 1, desc: "Optional pass threshold (0-1)" },
+    {
+      name: "case-sample-size",
+      type: "number",
+      min: 1,
+      max: 1e3,
+      desc: "Randomly sample this many dataset cases when the run starts (1-1000); omit to run all cases"
+    },
+    lockVersionFlag("run")
+  ],
+  risk: "write",
+  dryRun: (ctx) => evalDryRun(ctx, "PATCH", pathFor41(ctx), void 0, buildBody23(ctx)),
+  execute: async (ctx) => evalApi(ctx, "PATCH", pathFor41(ctx), void 0, buildBody23(ctx))
+};
+
+// src/commands/evaluation/delete-run.ts
+var PATH52 = "/evaluation-runs";
+function pathFor42(ctx) {
+  return `${PATH52}/${evalPathId(ctx, "id")}`;
+}
+function buildBody24(ctx) {
+  return { lock_version: ctx.num("lock-version") };
+}
+var deleteRun = {
+  service: "evaluation",
+  command: "+delete_run",
+  description: "Delete a draft evaluation run via DELETE /agenteval/api/v1/evaluation-runs/{runId}. Only DRAFT runs can be deleted; requires the current lock_version.",
+  flags: [...evalFlags(), ...idAndLockFlags("Run UUID", "run")],
+  risk: "high-risk-write",
+  dryRun: (ctx) => evalDryRun(ctx, "DELETE", pathFor42(ctx), void 0, buildBody24(ctx)),
+  execute: async (ctx) => evalApi(ctx, "DELETE", pathFor42(ctx), void 0, buildBody24(ctx))
+};
+
+// src/commands/evaluation/select-run-evaluators.ts
+var PATH53 = "/evaluation-runs";
+function pathFor43(ctx) {
+  return `${PATH53}/${evalPathId(ctx, "id")}/evaluators`;
+}
+function buildBody25(ctx) {
+  const evaluatorIds = ctx.json("evaluator-ids");
+  if (!Array.isArray(evaluatorIds) || evaluatorIds.length === 0 || !evaluatorIds.every((v) => typeof v === "string")) {
+    throw new Error(`--evaluator-ids must be a non-empty JSON array of evaluator UUIDs, e.g. '["<uuid>"]'`);
+  }
+  const body = { evaluator_ids: evaluatorIds, lock_version: ctx.num("lock-version") };
+  const versions = ctx.json("evaluator-versions-json");
+  if (versions !== void 0) {
+    if (!Array.isArray(versions) || !versions.every(
+      (v) => v !== null && typeof v === "object" && !Array.isArray(v) && typeof v.evaluator_id === "string" && typeof v.version_id === "string"
+    )) {
+      throw new Error(
+        '--evaluator-versions-json must be a JSON array of {"evaluator_id":"<uuid>","version_id":"<uuid>"} objects'
+      );
+    }
+    body.evaluator_versions = versions;
+  }
+  return body;
+}
+var selectRunEvaluators = {
+  service: "evaluation",
+  command: "+select_run_evaluators",
+  description: "Bind evaluators to a draft run via PUT /agenteval/api/v1/evaluation-runs/{runId}/evaluators. Required before +start_run; at least one active evaluator must be selected. Prefer pinning published evaluator versions from +list_evaluator_versions; never guess version UUIDs. Uses the current lock_version from +get_run and increments it.",
+  flags: [
+    ...evalFlags(),
+    idFlag("Run UUID"),
+    {
+      name: "evaluator-ids",
+      type: "json",
+      required: true,
+      desc: `JSON array of evaluator UUIDs to bind, e.g. '["<uuid-1>","<uuid-2>"]' (from +list_evaluators)`
+    },
+    {
+      name: "evaluator-versions-json",
+      type: "json",
+      desc: `Optional JSON array pinning published evaluator versions, e.g. '[{"evaluator_id":"<uuid>","version_id":"<uuid>"}]' (from +list_evaluator_versions)`
+    },
+    {
+      name: "lock-version",
+      type: "number",
+      required: true,
+      min: 0,
+      desc: "Current run lock_version (optimistic lock), from +get_run"
+    }
+  ],
+  risk: "write",
+  dryRun: (ctx) => evalDryRun(ctx, "PUT", pathFor43(ctx), void 0, buildBody25(ctx)),
+  execute: async (ctx) => evalApi(ctx, "PUT", pathFor43(ctx), void 0, buildBody25(ctx))
+};
+
+// src/commands/evaluation/list-run-evaluators.ts
+var PATH54 = "/evaluation-runs";
+function pathFor44(ctx) {
+  return `${PATH54}/${evalPathId(ctx, "id")}/evaluators`;
+}
+var listRunEvaluators = {
+  service: "evaluation",
+  command: "+list_run_evaluators",
+  description: "List the evaluators bound to a run via GET /agenteval/api/v1/evaluation-runs/{runId}/evaluators, including per-evaluator progress and score counts. Bind or replace them with +select_run_evaluators.",
+  flags: [...evalFlags(), idFlag("Run UUID")],
+  risk: "read",
+  dryRun: (ctx) => evalDryRun(ctx, "GET", pathFor44(ctx)),
+  execute: async (ctx) => evalApi(ctx, "GET", pathFor44(ctx))
+};
+
+// src/commands/evaluation/update-run-field-mapping.ts
+var PATH55 = "/evaluation-runs";
+function pathFor45(ctx) {
+  return `${PATH55}/${evalPathId(ctx, "id")}/field-mapping`;
+}
+function buildBody26(ctx) {
+  const fieldMapping = ctx.json("field-mapping-json");
+  if (fieldMapping === void 0) {
+    throw new Error("--field-mapping-json is required (schema_version/agent/evaluators, FIELD_MAPPING_V* contract)");
+  }
+  return { field_mapping_json: fieldMapping, lock_version: ctx.num("lock-version") };
+}
+var updateRunFieldMapping = {
+  service: "evaluation",
+  command: "+update_run_field_mapping",
+  description: "Set the field mapping on a draft run via PUT /agenteval/api/v1/evaluation-runs/{runId}/field-mapping. Required before +start_run; the agent input and every evaluator variable must be mapped. Uses the current lock_version and increments it.",
+  flags: [
+    ...evalFlags(),
+    ...idAndLockFlags("Run UUID", "run"),
+    {
+      name: "field-mapping-json",
+      type: "json",
+      required: true,
+      desc: "FieldMapping JSON (schema_version/agent/evaluators); V6 adds AGENT_EXECUTION_TRACE and AGENT_TOOL_CALLS for LIVE_AGENT Agent process scoring"
+    }
+  ],
+  risk: "write",
+  dryRun: (ctx) => evalDryRun(ctx, "PUT", pathFor45(ctx), void 0, buildBody26(ctx)),
+  execute: async (ctx) => evalApi(ctx, "PUT", pathFor45(ctx), void 0, buildBody26(ctx))
+};
+
+// src/commands/evaluation/update-run-result-filter-fields.ts
+var PATH56 = "/evaluation-runs";
+function pathFor46(ctx) {
+  return `${PATH56}/${evalPathId(ctx, "id")}/result-filter-fields`;
+}
+function buildBody27(ctx) {
+  const resultFilterFields = ctx.json("result-filter-fields-json");
+  if (resultFilterFields === void 0) {
+    throw new Error(`--result-filter-fields-json is required; pass an empty filter as '{"fields":[],"schema_version":"RESULT_FILTER_FIELDS_V1"}'`);
+  }
+  return { result_filter_fields_json: resultFilterFields, lock_version: ctx.num("lock-version") };
+}
+var updateRunResultFilterFields = {
+  service: "evaluation",
+  command: "+update_run_result_filter_fields",
+  description: "Set result filter fields on a draft run via PUT /agenteval/api/v1/evaluation-runs/{runId}/result-filter-fields. Required before +start_run even when no filter is needed (pass an empty fields array). Uses the current lock_version from +get_run and increments it.",
+  flags: [
+    ...evalFlags(),
+    idFlag("Run UUID"),
+    {
+      name: "result-filter-fields-json",
+      type: "json",
+      required: true,
+      desc: `ResultFilterFields JSON (schema_version/fields, max 5). Empty filter: '{"fields":[],"schema_version":"RESULT_FILTER_FIELDS_V1"}'`
+    },
+    {
+      name: "lock-version",
+      type: "number",
+      required: true,
+      min: 0,
+      desc: "Current run lock_version (optimistic lock), from +get_run"
+    }
+  ],
+  risk: "write",
+  dryRun: (ctx) => evalDryRun(ctx, "PUT", pathFor46(ctx), void 0, buildBody27(ctx)),
+  execute: async (ctx) => evalApi(ctx, "PUT", pathFor46(ctx), void 0, buildBody27(ctx))
+};
+
+// src/commands/evaluation/validate-run.ts
+var PATH57 = "/evaluation-runs";
+function pathFor47(ctx) {
+  return `${PATH57}/${evalPathId(ctx, "id")}/validate`;
+}
+var validateRun = {
+  service: "evaluation",
+  command: "+validate_run",
+  description: "Run the same preflight validation as +start_run via POST /agenteval/api/v1/evaluation-runs/{runId}/validate, without starting the run. Sends no request body and needs no lock_version. Returns validation issues (evaluator binding, field mapping, result filter fields, subject connectivity).",
+  flags: [...evalFlags(), idFlag("Run UUID")],
+  risk: "read",
+  dryRun: (ctx) => evalDryRun(ctx, "POST", pathFor47(ctx)),
+  execute: async (ctx) => evalApi(ctx, "POST", pathFor47(ctx))
+};
+
+// src/commands/evaluation/start-run.ts
+var PATH58 = "/evaluation-runs";
+function pathFor48(ctx) {
+  return `${PATH58}/${evalPathId(ctx, "id")}/start`;
+}
+function buildBody28(ctx) {
+  return { lock_version: ctx.num("lock-version") };
+}
+var startRun = {
+  service: "evaluation",
+  command: "+start_run",
+  description: "Start an evaluation run via POST /agenteval/api/v1/evaluation-runs/{runId}/start. Runs an agent compatibility preflight, then atomically freezes snapshots and queues the run. Requires the current lock_version from +get_run.",
+  flags: [
+    ...evalFlags(),
+    idFlag("Run UUID"),
+    {
+      name: "lock-version",
+      type: "number",
+      required: true,
+      min: 0,
+      desc: "Current run lock_version (optimistic lock), from +get_run"
+    }
+  ],
+  risk: "write",
+  dryRun: (ctx) => evalDryRun(ctx, "POST", pathFor48(ctx), void 0, buildBody28(ctx)),
+  execute: async (ctx) => evalApi(ctx, "POST", pathFor48(ctx), void 0, buildBody28(ctx))
+};
+
+// src/commands/evaluation/cancel-run.ts
+var PATH59 = "/evaluation-runs";
+function pathFor49(ctx) {
+  return `${PATH59}/${evalPathId(ctx, "id")}/cancel`;
+}
+function buildBody29(ctx) {
+  return { lock_version: ctx.num("lock-version") };
+}
+var cancelRun = {
+  service: "evaluation",
+  command: "+cancel_run",
+  description: "Request cancellation of an evaluation run via POST /agenteval/api/v1/evaluation-runs/{runId}/cancel. Requires the current lock_version from +get_run.",
+  flags: [
+    ...evalFlags(),
+    idFlag("Run UUID"),
+    {
+      name: "lock-version",
+      type: "number",
+      required: true,
+      min: 0,
+      desc: "Current run lock_version (optimistic lock), from +get_run"
+    }
+  ],
+  risk: "high-risk-write",
+  dryRun: (ctx) => evalDryRun(ctx, "POST", pathFor49(ctx), void 0, buildBody29(ctx)),
+  execute: async (ctx) => evalApi(ctx, "POST", pathFor49(ctx), void 0, buildBody29(ctx))
+};
+
+// src/commands/evaluation/run-overview.ts
+var PATH60 = "/evaluation-runs";
+function pathFor50(ctx) {
+  return `${PATH60}/${evalPathId(ctx, "id")}/overview`;
+}
+var runOverview = {
+  service: "evaluation",
+  command: "+run_overview",
+  description: "Get an evaluation run overview via GET /agenteval/api/v1/evaluation-runs/{runId}/overview: progress, average score, pass rate, score distribution, and result fields.",
+  flags: [...evalFlags(), idFlag("Run UUID")],
+  risk: "read",
+  dryRun: (ctx) => evalDryRun(ctx, "GET", pathFor50(ctx)),
+  execute: async (ctx) => evalApi(ctx, "GET", pathFor50(ctx))
+};
+
+// src/commands/evaluation/run-cases.ts
+var PATH61 = "/evaluation-runs";
+function pathFor51(ctx) {
+  return `${PATH61}/${evalPathId(ctx, "id")}/cases`;
+}
+function buildParams6(ctx) {
+  const params = {};
+  const status = ctx.str("status");
+  if (status) params.status = status;
+  const evidenceCompleteness = ctx.str("evidence-completeness");
+  if (evidenceCompleteness) params.evidence_completeness = evidenceCompleteness;
+  const search = ctx.str("search");
+  if (search) params.search = search;
+  const evaluationStatus = ctx.str("evaluation-status");
+  if (evaluationStatus) params.evaluation_status = evaluationStatus;
+  const scoreStatus = ctx.str("score-status");
+  if (scoreStatus) params.score_status = scoreStatus;
+  const evaluatorId = ctx.str("evaluator-id");
+  if (evaluatorId) params.evaluator_id = evaluatorId;
+  const evaluatorIds = ctx.json("evaluator-ids");
+  if (evaluatorIds !== void 0) {
+    if (!Array.isArray(evaluatorIds) || evaluatorIds.length < 1 || evaluatorIds.length > 8 || !evaluatorIds.every((v) => typeof v === "string")) {
+      throw new Error(`--evaluator-ids must be a JSON array of 1-8 run evaluator UUIDs, e.g. '["<uuid>"]'`);
+    }
+    params.evaluator_ids = evaluatorIds.join(",");
+  }
+  const minScore = ctx.optionalNum("min-score");
+  if (minScore !== void 0) params.min_score = minScore;
+  const maxScore = ctx.optionalNum("max-score");
+  if (maxScore !== void 0) params.max_score = maxScore;
+  const scoreGte = ctx.optionalNum("score-gte");
+  if (scoreGte !== void 0) params.score_gte = scoreGte;
+  const scoreLte = ctx.optionalNum("score-lte");
+  if (scoreLte !== void 0) params.score_lte = scoreLte;
+  const fieldFilters = ctx.json("field-filters-json");
+  if (fieldFilters !== void 0) {
+    if (!Array.isArray(fieldFilters) || fieldFilters.length > 5) {
+      throw new Error("--field-filters-json must be a JSON array of at most 5 typed filters");
+    }
+    params.field_filters = JSON.stringify(fieldFilters);
+  }
+  const sort = ctx.str("sort");
+  if (sort) params.sort = sort;
+  const sortEvaluatorId = ctx.str("sort-evaluator-id");
+  if (sortEvaluatorId) params.sort_evaluator_id = sortEvaluatorId;
+  const order = ctx.str("order");
+  if (order) params.order = order;
+  const cursor = ctx.str("cursor");
+  if (cursor) params.cursor = cursor;
+  const limit = ctx.optionalNum("limit");
+  if (limit !== void 0) params.limit = limit;
+  const offset = ctx.optionalNum("offset");
+  if (offset !== void 0) params.offset = offset;
+  return params;
+}
+var runCases = {
+  service: "evaluation",
+  command: "+run_cases",
+  description: "List evaluation run case results via GET /agenteval/api/v1/evaluation-runs/{runId}/cases with rich filtering (status, evidence completeness, free-text search, evaluation/score status, evaluator scope, score range, frozen field filters, sort). Returns a cursor-paginated page.",
+  flags: [
+    ...evalFlags(),
+    idFlag("Run UUID"),
+    {
+      name: "status",
+      type: "string",
+      desc: "Filter by case status: PENDING | RUNNING | BLOCKED | SUCCEEDED | FAILED | CANCELLED | UNKNOWN"
+    },
+    {
+      name: "evidence-completeness",
+      type: "string",
+      desc: "Filter by evidence completeness: NONE | PARTIAL | COMPLETE | UNKNOWN"
+    },
+    {
+      name: "search",
+      type: "string",
+      maxLength: 128,
+      sensitive: true,
+      desc: "Free-text search (max 128) matching Agent output, public errors, external run/session IDs and runtime fingerprint; redacted from logs"
+    },
+    {
+      name: "evaluation-status",
+      type: "string",
+      desc: "Filter by evaluation status: PENDING | RUNNING | SUCCEEDED | PARTIALLY_FAILED | FAILED | CANCELLED"
+    },
+    {
+      name: "score-status",
+      type: "string",
+      desc: "Filter by score status: PENDING | RUNNING | SUCCEEDED | FAILED | CANCELLED"
+    },
+    { name: "evaluator-id", type: "string", desc: "Filter by a single run evaluator UUID" },
+    {
+      name: "evaluator-ids",
+      type: "json",
+      desc: `JSON array of 1-8 run evaluator UUIDs, e.g. '["<uuid-1>","<uuid-2>"]' (from +list_run_evaluators)`
+    },
+    { name: "min-score", type: "number", min: 0, max: 1, desc: "Minimum average score (0-1)" },
+    { name: "max-score", type: "number", min: 0, max: 1, desc: "Maximum average score (0-1)" },
+    { name: "score-gte", type: "number", min: 0, max: 1, desc: "Minimum evaluator score (0-1)" },
+    { name: "score-lte", type: "number", min: 0, max: 1, desc: "Maximum evaluator score (0-1)" },
+    {
+      name: "field-filters-json",
+      type: "json",
+      sensitive: true,
+      desc: `JSON array of up to 5 typed filters over frozen result fields; each needs field_key and may combine state=VALUE with one typed criterion, while numeric filters may use both number_gte and number_lte, e.g. '[{"field_key":"score","number_gte":0.5,"number_lte":1}]'`
+    },
+    {
+      name: "sort",
+      type: "string",
+      desc: "Sort key: MIN_SCORE | AVERAGE_SCORE | EVALUATOR_SCORE (pair EVALUATOR_SCORE with --sort-evaluator-id)"
+    },
+    { name: "sort-evaluator-id", type: "string", desc: "Run evaluator UUID used when --sort EVALUATOR_SCORE" },
+    { name: "order", type: "string", desc: "Sort order: asc | desc (default asc)" },
+    { name: "cursor", type: "string", desc: "Opaque pagination cursor from the previous page" },
+    { name: "limit", type: "number", min: 1, max: 1e3, desc: "Page size (1-1000, default 50)" },
+    { name: "offset", type: "number", min: 0, desc: "Non-negative offset into the result set (default 0)" }
+  ],
+  risk: "read",
+  dryRun: (ctx) => evalDryRun(ctx, "GET", pathFor51(ctx), buildParams6(ctx)),
+  execute: async (ctx) => evalApi(ctx, "GET", pathFor51(ctx), buildParams6(ctx))
+};
+
+// src/commands/evaluation/get-run-case.ts
+var PATH62 = "/evaluation-runs";
+function pathFor52(ctx) {
+  return `${PATH62}/${evalPathId(ctx, "id")}/cases/${evalPathId(ctx, "case-run-id")}`;
+}
+var getRunCase = {
+  service: "evaluation",
+  command: "+get_run_case",
+  description: "Get one evaluation case result in full detail via GET /agenteval/api/v1/evaluation-runs/{runId}/cases/{caseRunId}: agent input/output, per-evaluator scores, reasons, and error details. Find caseRunId via +run_cases.",
+  flags: [...evalFlags(), idFlag("Run UUID"), { name: "case-run-id", type: "string", required: true, desc: "Case run UUID from +run_cases items[].case_run_id" }],
+  risk: "read",
+  dryRun: (ctx) => evalDryRun(ctx, "GET", pathFor52(ctx)),
+  execute: async (ctx) => evalApi(ctx, "GET", pathFor52(ctx))
+};
+
+// src/commands/evaluation/export-run-results.ts
+var PATH63 = "/evaluation-runs";
+function pathFor53(ctx) {
+  return `${PATH63}/${evalPathId(ctx, "id")}/export`;
+}
+function buildParams7(ctx) {
+  const params = {};
+  const format = ctx.str("export-format");
+  if (format) params.format = format;
+  return params;
+}
+var exportRunResults = {
+  service: "evaluation",
+  command: "+export_run_results",
+  description: "Queue an asynchronous export of an evaluation run result via POST /agenteval/api/v1/evaluation-runs/{runId}/export. Requires an Idempotency-Key; returns 202 with File metadata (poll +get_file until COMPLETED, then use file download --output <path>).",
+  flags: [
+    ...evalFlags(),
+    idFlag("Run UUID"),
+    { name: "export-format", type: "string", desc: "Export format: CSV | JSONL (default CSV)" },
+    {
+      name: "idempotency-key",
+      type: "string",
+      required: true,
+      hint: "Required. Use a fresh value per export attempt (max 191 chars) sent as the Idempotency-Key header.",
+      desc: "Unique Idempotency-Key header value (1-191 characters)"
+    }
+  ],
+  risk: "write",
+  dryRun: (ctx) => evalDryRun(ctx, "POST", pathFor53(ctx), buildParams7(ctx), void 0, {
+    idempotencyKey: ctx.str("idempotency-key")
+  }),
+  execute: async (ctx) => evalApi(ctx, "POST", pathFor53(ctx), buildParams7(ctx), void 0, {
+    idempotencyKey: ctx.str("idempotency-key")
+  })
+};
+
+// src/commands/evaluation/export-run-low-scores.ts
+var PATH64 = "/evaluation-runs";
+function pathFor54(ctx) {
+  return `${PATH64}/${evalPathId(ctx, "id")}/low-score-export`;
+}
+function buildParams8(ctx) {
+  const params = { max_score: ctx.num("max-score") };
+  const format = ctx.str("export-format");
+  if (format) params.format = format;
+  const minScore = ctx.optionalNum("min-score");
+  if (minScore !== void 0) params.min_score = minScore;
+  const status = ctx.str("status");
+  if (status) params.status = status;
+  return params;
+}
+var exportRunLowScores = {
+  service: "evaluation",
+  command: "+export_run_low_scores",
+  description: "Queue an asynchronous export of low-scoring case results via POST /agenteval/api/v1/evaluation-runs/{runId}/low-score-export. Requires --max-score and an Idempotency-Key; returns 202 with File metadata (poll +get_file until COMPLETED, then use file download --output <path>).",
+  flags: [
+    ...evalFlags(),
+    idFlag("Run UUID"),
+    { name: "max-score", type: "number", required: true, min: 0, max: 1, desc: "Upper score bound (0-1); only cases scoring <= this value are exported" },
+    { name: "min-score", type: "number", min: 0, max: 1, desc: "Optional lower score bound (0-1)" },
+    { name: "status", type: "string", desc: "Optional case status filter, e.g. SUCCEEDED | FAILED" },
+    { name: "export-format", type: "string", desc: "Export format: CSV | JSONL (default CSV)" },
+    {
+      name: "idempotency-key",
+      type: "string",
+      required: true,
+      hint: "Required. Use a fresh value per export attempt (max 191 chars) sent as the Idempotency-Key header.",
+      desc: "Unique Idempotency-Key header value (1-191 characters)"
+    }
+  ],
+  risk: "write",
+  dryRun: (ctx) => evalDryRun(ctx, "POST", pathFor54(ctx), buildParams8(ctx), void 0, {
+    idempotencyKey: ctx.str("idempotency-key")
+  }),
+  execute: async (ctx) => evalApi(ctx, "POST", pathFor54(ctx), buildParams8(ctx), void 0, {
+    idempotencyKey: ctx.str("idempotency-key")
+  })
+};
+
+// src/commands/evaluation/file-download-url.ts
+var PATH65 = "/files";
+function pathFor55(ctx) {
+  return `${PATH65}/${evalPathId(ctx, "id")}/download-url`;
+}
+var fileDownloadUrl = {
+  service: "evaluation",
+  command: "+file_download_url",
+  description: "Create a temporary download URL for a staged file via POST /agenteval/api/v1/files/{fileId}/download-url. Returns download_url and expires_in_seconds; local storage URLs refer to the server filesystem. Use file download for authenticated remote downloads.",
+  flags: [...evalFlags(), idFlag("File UUID")],
+  risk: "read",
+  dryRun: (ctx) => evalDryRun(ctx, "POST", pathFor55(ctx)),
+  execute: async (ctx) => evalApi(ctx, "POST", pathFor55(ctx))
+};
+
+// src/commands/evaluation/get-file.ts
+var PATH66 = "/files";
+function pathFor56(ctx) {
+  return `${PATH66}/${evalPathId(ctx, "id")}`;
+}
+var getFile = {
+  service: "evaluation",
+  command: "+get_file",
+  description: "Get file metadata via GET /agenteval/api/v1/files/{id}. Completes the export chain: +export_run_results / +export_dataset return a file id, +get_file reads its metadata, +file_download_url mints a temporary download URL.",
+  flags: [...evalFlags(), idFlag("File UUID")],
+  risk: "read",
+  dryRun: (ctx) => evalDryRun(ctx, "GET", pathFor56(ctx)),
+  execute: async (ctx) => evalApi(ctx, "GET", pathFor56(ctx))
+};
+
+// src/commands/evaluation/create-next-task-version-draft.ts
+var PATH67 = "/evaluation-runs";
+function pathFor57(ctx) {
+  return `${PATH67}/${evalPathId(ctx, "id")}/new-version`;
+}
+var createNextTaskVersionDraft = {
+  service: "evaluation",
+  command: "+create_next_task_version_draft",
+  description: "Create the next draft copy from the task version pinned by a run via POST /agenteval/api/v1/evaluation-runs/{id}/new-version. Sends no request body; returns the new draft run.",
+  flags: [...evalFlags(), idFlag("Source run UUID")],
+  risk: "write",
+  dryRun: (ctx) => evalDryRun(ctx, "POST", pathFor57(ctx)),
+  execute: async (ctx) => evalApi(ctx, "POST", pathFor57(ctx))
+};
+
+// src/commands/evaluation/list-evaluation-task-versions.ts
+var PATH68 = "/evaluation-tasks";
+function pathFor58(ctx) {
+  return `${PATH68}/${evalPathId(ctx, "task-id")}/versions`;
+}
+var listEvaluationTaskVersions = {
+  service: "evaluation",
+  command: "+list_evaluation_task_versions",
+  description: "List published versions of an evaluation task via GET /agenteval/api/v1/evaluation-tasks/{taskId}/versions. Each version pins a dataset version; runs pin one immutable version.",
+  flags: [
+    ...evalFlags(),
+    { name: "task-id", type: "string", required: true, desc: "Evaluation task UUID" }
+  ],
+  risk: "read",
+  dryRun: (ctx) => evalDryRun(ctx, "GET", pathFor58(ctx)),
+  execute: async (ctx) => evalApi(ctx, "GET", pathFor58(ctx))
+};
+
+// src/commands/evaluation/retry-failed-run-cases.ts
+var PATH69 = "/evaluation-runs";
+function pathFor59(ctx) {
+  return `${PATH69}/${evalPathId(ctx, "id")}/retry-failed-cases`;
+}
+var retryFailedRunCases = {
+  service: "evaluation",
+  command: "+retry_failed_run_cases",
+  description: "Requeue Agent-stage FAILED, BLOCKED and UNKNOWN cases of a run via POST /agenteval/api/v1/evaluation-runs/{id}/retry-failed-cases. Sends {lock_version}. Successful cases are preserved; the immutable run snapshot is reused, the execution epoch increases and aggregates are recomputed.",
+  flags: [...evalFlags(), ...idAndLockFlags("Run UUID", "run")],
+  risk: "write",
+  dryRun: (ctx) => evalDryRun(ctx, "POST", pathFor59(ctx), void 0, { lock_version: ctx.num("lock-version") }),
+  execute: async (ctx) => evalApi(ctx, "POST", pathFor59(ctx), void 0, { lock_version: ctx.num("lock-version") })
+};
+
+// src/commands/evaluation/get-run-case-trace.ts
+var PATH70 = "/evaluation-runs";
+function pathFor60(ctx) {
+  return `${PATH70}/${evalPathId(ctx, "id")}/cases/${evalPathId(ctx, "case-run-id")}/trace`;
+}
+var getRunCaseTrace = {
+  service: "evaluation",
+  command: "+get_run_case_trace",
+  description: "Get the immutable normalized execution trace of a case via GET /agenteval/api/v1/evaluation-runs/{id}/cases/{caseRunId}/trace. Only available for LIVE_AGENT runs with subject AGENT; capture status is independent of case success. Traces carry at most 500 spans and may be truncated (PARTIAL is not a complete trajectory). Never echo hidden chain-of-thought, credentials, cookies, auth headers or unredacted tool input/output into reports.",
+  flags: [
+    ...evalFlags(),
+    { name: "id", type: "string", required: true, desc: "Run UUID" },
+    { name: "case-run-id", type: "string", required: true, desc: "Case run UUID" }
+  ],
+  risk: "read",
+  dryRun: (ctx) => evalDryRun(ctx, "GET", pathFor60(ctx)),
+  execute: async (ctx) => evalApi(ctx, "GET", pathFor60(ctx))
+};
+
+// src/commands/evaluation/retry-run-case-trace.ts
+var PATH71 = "/evaluation-runs";
+function pathFor61(ctx) {
+  return `${PATH71}/${evalPathId(ctx, "id")}/cases/${evalPathId(ctx, "case-run-id")}/trace:retry`;
+}
+var retryRunCaseTrace = {
+  service: "evaluation",
+  command: "+retry_run_case_trace",
+  description: "ADMIN-only retry of a failed AI Monitor-backed trace capture via POST /agenteval/api/v1/evaluation-runs/{id}/cases/{caseRunId}/trace:retry. Sends no request body; only retryable captures are accepted.",
+  flags: [
+    ...evalFlags(),
+    { name: "id", type: "string", required: true, desc: "Run UUID" },
+    { name: "case-run-id", type: "string", required: true, desc: "Case run UUID" }
+  ],
+  risk: "write",
+  dryRun: (ctx) => evalDryRun(ctx, "POST", pathFor61(ctx)),
+  execute: async (ctx) => evalApi(ctx, "POST", pathFor61(ctx))
+};
+
+// src/commands/evaluation/run-distribution.ts
+var PATH72 = "/evaluation-runs";
+function pathFor62(ctx) {
+  return `${PATH72}/${evalPathId(ctx, "id")}/distribution`;
+}
+function buildParams9(ctx) {
+  const params = {};
+  const runEvaluatorId = ctx.str("run-evaluator-id");
+  if (runEvaluatorId) params.run_evaluator_id = runEvaluatorId;
+  return params;
+}
+var runDistribution = {
+  service: "evaluation",
+  command: "+run_distribution",
+  description: "Get the five fixed score buckets of a run via GET /agenteval/api/v1/evaluation-runs/{id}/distribution. Pass --run-evaluator-id to scope the buckets to one run evaluator binding.",
+  flags: [
+    ...evalFlags(),
+    idFlag("Run UUID"),
+    { name: "run-evaluator-id", type: "string", desc: "Run evaluator UUID to scope the distribution to" }
+  ],
+  risk: "read",
+  dryRun: (ctx) => evalDryRun(ctx, "GET", pathFor62(ctx), buildParams9(ctx)),
+  execute: async (ctx) => evalApi(ctx, "GET", pathFor62(ctx), buildParams9(ctx))
+};
+
+// src/commands/evaluation/copy-run-case.ts
+var PATH73 = "/evaluation-runs";
+function pathFor63(ctx) {
+  return `${PATH73}/${evalPathId(ctx, "id")}/cases/${evalPathId(ctx, "case-run-id")}/copy`;
+}
+var copyRunCase = {
+  service: "evaluation",
+  command: "+copy_run_case",
+  description: "Copy a case result as sanitized structured data via POST /agenteval/api/v1/evaluation-runs/{id}/cases/{caseRunId}/copy. Sends no request body; the response is a sanitized CaseRunResult safe for reuse in dataset cases or reports.",
+  flags: [
+    ...evalFlags(),
+    { name: "id", type: "string", required: true, desc: "Run UUID" },
+    { name: "case-run-id", type: "string", required: true, desc: "Case run UUID" }
+  ],
+  risk: "read",
+  dryRun: (ctx) => evalDryRun(ctx, "POST", pathFor63(ctx)),
+  execute: async (ctx) => evalApi(ctx, "POST", pathFor63(ctx))
+};
+
+// src/commands/evaluation/transfer-run-owner.ts
+var PATH74 = "/evaluation-runs";
+function pathFor64(ctx) {
+  return `${PATH74}/${evalPathId(ctx, "id")}/transfer-owner`;
+}
+function buildBody30(ctx) {
+  return { owner_user_id: ctx.str("owner-user-id"), lock_version: ctx.num("lock-version") };
+}
+var transferRunOwner = {
+  service: "evaluation",
+  command: "+transfer_run_owner",
+  description: "Transfer evaluation run ownership to another user via POST /agenteval/api/v1/evaluation-runs/{id}/transfer-owner. Changes resource permissions; requires ADMIN role and the current run lock_version. Use +list_project_members to discover real user UUIDs.",
+  flags: [
+    ...evalFlags(),
+    ...idAndLockFlags("Run UUID", "run"),
+    { name: "owner-user-id", type: "string", required: true, desc: "User UUID of the new owner" }
+  ],
+  risk: "high-risk-write",
+  dryRun: (ctx) => evalDryRun(ctx, "POST", pathFor64(ctx), void 0, buildBody30(ctx)),
+  execute: async (ctx) => evalApi(ctx, "POST", pathFor64(ctx), void 0, buildBody30(ctx))
+};
+
+// src/commands/evaluation/list-schedules.ts
+var PATH75 = "/evaluation-run-schedules";
+function buildParams10(ctx) {
+  const params = {};
+  const status = ctx.str("status");
+  if (status) params.status = status;
+  const cursor = ctx.str("cursor");
+  if (cursor) params.cursor = cursor;
+  const limit = ctx.optionalNum("limit");
+  if (limit !== void 0) params.limit = limit;
+  return params;
+}
+var listSchedules = {
+  service: "evaluation",
+  command: "+list_schedules",
+  description: "List evaluation run schedules via GET /agenteval/api/v1/evaluation-run-schedules. Returns a cursor-paginated page with next occurrence and status.",
+  flags: [
+    ...evalFlags(),
+    {
+      name: "status",
+      type: "string",
+      desc: "Filter by schedule status: PENDING | PROCESSING | COMPLETED | FAILED | CANCELLED"
+    },
+    { name: "cursor", type: "string", desc: "Opaque pagination cursor from the previous page" },
+    { name: "limit", type: "number", min: 1, max: 200, desc: "Page size (1-200, default 50)" }
+  ],
+  risk: "read",
+  dryRun: (ctx) => evalDryRun(ctx, "GET", PATH75, buildParams10(ctx)),
+  execute: async (ctx) => evalApi(ctx, "GET", PATH75, buildParams10(ctx))
+};
+
+// src/commands/evaluation/create-schedule.ts
+var PATH76 = "/evaluation-run-schedules";
+function buildBody31(ctx) {
+  const body = {
+    run_id: ctx.str("run-id"),
+    frequency: ctx.str("frequency"),
+    time_zone: ctx.str("time-zone")
+  };
+  const minuteOfHour = ctx.optionalNum("minute-of-hour");
+  if (minuteOfHour !== void 0) body.minute_of_hour = minuteOfHour;
+  const hourOfDay = ctx.optionalNum("hour-of-day");
+  if (hourOfDay !== void 0) body.hour_of_day = hourOfDay;
+  const dayOfWeek = ctx.optionalNum("day-of-week");
+  if (dayOfWeek !== void 0) body.day_of_week = dayOfWeek;
+  const dayOfMonth = ctx.optionalNum("day-of-month");
+  if (dayOfMonth !== void 0) body.day_of_month = dayOfMonth;
+  return body;
+}
+var createSchedule = {
+  service: "evaluation",
+  command: "+create_schedule",
+  description: "Create a recurring evaluation schedule from an existing run template via POST /agenteval/api/v1/evaluation-run-schedules. Each occurrence creates and starts a new immutable run.",
+  flags: [
+    ...evalFlags(),
+    { name: "run-id", type: "string", required: true, desc: "Template run UUID to schedule" },
+    {
+      name: "frequency",
+      type: "string",
+      required: true,
+      desc: "HOURLY | DAILY | WEEKLY | MONTHLY. HOURLY runs at minute 0 and must omit minute fields"
+    },
+    {
+      name: "time-zone",
+      type: "string",
+      required: true,
+      desc: "IANA time zone, e.g. Asia/Shanghai"
+    },
+    {
+      name: "minute-of-hour",
+      type: "number",
+      min: 0,
+      max: 59,
+      desc: "Minute of the hour. Required for DAILY/WEEKLY/MONTHLY (send 0 for hourly)"
+    },
+    { name: "hour-of-day", type: "number", min: 0, max: 23, desc: "Hour of the day (0-23)" },
+    {
+      name: "day-of-week",
+      type: "number",
+      min: 1,
+      max: 7,
+      desc: "Day of the week for WEEKLY: Monday is 1, Sunday is 7"
+    },
+    { name: "day-of-month", type: "number", min: 1, max: 31, desc: "Day of the month for MONTHLY (1-31)" }
+  ],
+  risk: "write",
+  dryRun: (ctx) => evalDryRun(ctx, "POST", PATH76, void 0, buildBody31(ctx)),
+  execute: async (ctx) => evalApi(ctx, "POST", PATH76, void 0, buildBody31(ctx))
+};
+
+// src/commands/evaluation/update-schedule.ts
+var PATH77 = "/evaluation-run-schedules";
+function pathFor65(ctx) {
+  return `${PATH77}/${evalPathId(ctx, "id")}`;
+}
+function buildBody32(ctx) {
+  const body = {
+    frequency: ctx.str("frequency"),
+    time_zone: ctx.str("time-zone"),
+    lock_version: ctx.num("lock-version")
+  };
+  const minuteOfHour = ctx.optionalNum("minute-of-hour");
+  if (minuteOfHour !== void 0) body.minute_of_hour = minuteOfHour;
+  const hourOfDay = ctx.optionalNum("hour-of-day");
+  if (hourOfDay !== void 0) body.hour_of_day = hourOfDay;
+  const dayOfWeek = ctx.optionalNum("day-of-week");
+  if (dayOfWeek !== void 0) body.day_of_week = dayOfWeek;
+  const dayOfMonth = ctx.optionalNum("day-of-month");
+  if (dayOfMonth !== void 0) body.day_of_month = dayOfMonth;
+  return body;
+}
+var updateSchedule = {
+  service: "evaluation",
+  command: "+update_schedule",
+  description: "Update a run schedule via PATCH /agenteval/api/v1/evaluation-run-schedules/{id}: change frequency, time zone, or occurrence time. Requires the current schedule lock_version from +list_schedules.",
+  flags: [
+    ...evalFlags(),
+    ...idAndLockFlags("Schedule UUID", "schedule"),
+    {
+      name: "frequency",
+      type: "string",
+      required: true,
+      desc: "HOURLY | DAILY | WEEKLY | MONTHLY. HOURLY runs at minute 0 and must omit minute fields"
+    },
+    { name: "time-zone", type: "string", required: true, desc: "IANA time zone, e.g. Asia/Shanghai" },
+    { name: "minute-of-hour", type: "number", min: 0, max: 59, desc: "Minute of the hour. Required for DAILY/WEEKLY/MONTHLY" },
+    { name: "hour-of-day", type: "number", min: 0, max: 23, desc: "Hour of the day (0-23)" },
+    { name: "day-of-week", type: "number", min: 1, max: 7, desc: "Day of the week for WEEKLY: Monday is 1, Sunday is 7" },
+    { name: "day-of-month", type: "number", min: 1, max: 31, desc: "Day of the month for MONTHLY (1-31)" }
+  ],
+  risk: "write",
+  dryRun: (ctx) => evalDryRun(ctx, "PATCH", pathFor65(ctx), void 0, buildBody32(ctx)),
+  execute: async (ctx) => evalApi(ctx, "PATCH", pathFor65(ctx), void 0, buildBody32(ctx))
+};
+
+// src/commands/evaluation/delete-schedule.ts
+var PATH78 = "/evaluation-run-schedules";
+function pathFor66(ctx) {
+  return `${PATH78}/${evalPathId(ctx, "id")}`;
+}
+function buildBody33(ctx) {
+  return { lock_version: ctx.num("lock-version") };
+}
+var deleteSchedule = {
+  service: "evaluation",
+  command: "+delete_schedule",
+  description: "Delete a scheduled evaluation in any status via DELETE /agenteval/api/v1/evaluation-run-schedules/{id}. An occurrence already claimed by a worker may finish, but no future occurrence is created. Requires the current lock_version from +list_schedules.",
+  flags: [
+    ...evalFlags(),
+    idFlag("Schedule UUID"),
+    {
+      name: "lock-version",
+      type: "number",
+      required: true,
+      min: 0,
+      desc: "Current schedule lock_version (optimistic lock), from +list_schedules"
+    }
+  ],
+  risk: "high-risk-write",
+  dryRun: (ctx) => evalDryRun(ctx, "DELETE", pathFor66(ctx), void 0, buildBody33(ctx)),
+  execute: async (ctx) => evalApi(ctx, "DELETE", pathFor66(ctx), void 0, buildBody33(ctx))
+};
+
+// src/commands/evaluation/get-te-report-config.ts
+var PATH79 = "/te-report-config";
+var getTeReportConfig = {
+  service: "evaluation",
+  command: "+get_te_report_config",
+  description: "Get the project TE reporting config via GET /agenteval/api/v1/te-report-config. Config is null when unset; the response also carries the deployment default base URL. Read its lock_version before +save_te_report_config.",
+  flags: [...evalFlags()],
+  risk: "read",
+  dryRun: (ctx) => evalDryRun(ctx, "GET", PATH79),
+  execute: async (ctx) => evalApi(ctx, "GET", PATH79)
+};
+
+// src/commands/evaluation/save-te-report-config.ts
+var PATH80 = "/te-report-config";
+function buildBody34(ctx) {
+  const body = {
+    base_url: ctx.str("base-url"),
+    app_id: ctx.str("app-id")
+  };
+  const lockVersion = ctx.optionalNum("lock-version");
+  if (lockVersion !== void 0) body.lock_version = lockVersion;
+  return body;
+}
+var saveTeReportConfig = {
+  service: "evaluation",
+  command: "+save_te_report_config",
+  description: "Create or update the project TE reporting config via PUT /agenteval/api/v1/te-report-config. Omit --lock-version on first create; on update pass the current lock_version from +get_te_report_config (0 is a valid version).",
+  flags: [
+    ...evalFlags(),
+    { name: "base-url", type: "string", required: true, desc: "ThinkingData base URL (absolute URI, max 1000 chars)" },
+    { name: "app-id", type: "string", required: true, desc: "ThinkingData app id (max 128 chars)" },
+    {
+      name: "lock-version",
+      type: "number",
+      min: 0,
+      desc: "Current config lock_version when updating an existing config (from +get_te_report_config); omit on first create"
+    }
+  ],
+  risk: "write",
+  dryRun: (ctx) => evalDryRun(ctx, "PUT", PATH80, void 0, buildBody34(ctx)),
+  execute: async (ctx) => evalApi(ctx, "PUT", PATH80, void 0, buildBody34(ctx))
+};
+
+// src/commands/evaluation/get-ai-monitor-connection.ts
+var PATH81 = "/ai-monitor-connection";
+var getAiMonitorConnection = {
+  service: "evaluation",
+  command: "+get_ai_monitor_connection",
+  description: "Get the project AI Monitor connection via GET /agenteval/api/v1/ai-monitor-connection. Connection is null when unset. Read its lock_version before +save_ai_monitor_connection.",
+  flags: [...evalFlags()],
+  risk: "read",
+  dryRun: (ctx) => evalDryRun(ctx, "GET", PATH81),
+  execute: async (ctx) => evalApi(ctx, "GET", PATH81)
+};
+
+// src/commands/evaluation/save-ai-monitor-connection.ts
+var PATH82 = "/ai-monitor-connection";
+var REQUIRED_CLAIM_KEYS = ["user_id", "te_user_id", "name", "company_id"];
+function buildBody35(ctx) {
+  const claims = ctx.json("session-claims-json");
+  if (claims === null || typeof claims !== "object" || Array.isArray(claims) || !REQUIRED_CLAIM_KEYS.every((key) => typeof claims[key] === "string")) {
+    throw new Error(
+      "--session-claims-json must be a JSON object with string user_id, te_user_id, name and company_id (is_root/platform_access optional)"
+    );
+  }
+  const body = {
+    base_url: ctx.str("base-url"),
+    credential_id: ctx.str("credential-id"),
+    session_claims: claims
+  };
+  const lockVersion = ctx.optionalNum("lock-version");
+  if (lockVersion !== void 0) body.lock_version = lockVersion;
+  return body;
+}
+function redactedDryRunBody(ctx) {
+  const body = buildBody35(ctx);
+  if (body.session_claims !== void 0) body.session_claims = "***redacted***";
+  return body;
+}
+var saveAiMonitorConnection = {
+  service: "evaluation",
+  command: "+save_ai_monitor_connection",
+  description: "Create or update the project AI Monitor connection via PUT /agenteval/api/v1/ai-monitor-connection. The credential must be of type AI_MONITOR_SESSION. Omit --lock-version on first create; on update pass the current lock_version from +get_ai_monitor_connection (0 is a valid version).",
+  flags: [
+    ...evalFlags(),
+    { name: "base-url", type: "string", required: true, desc: "AI Monitor base URL (absolute URI, max 1000 chars)" },
+    {
+      name: "credential-id",
+      type: "string",
+      required: true,
+      desc: "Credential UUID of type AI_MONITOR_SESSION (from +list_credentials)"
+    },
+    {
+      name: "session-claims-json",
+      type: "json",
+      required: true,
+      sensitive: true,
+      desc: "Session claims JSON with required string keys user_id, te_user_id, name, company_id (optional is_root, platform_access)"
+    },
+    {
+      name: "lock-version",
+      type: "number",
+      min: 0,
+      desc: "Current connection lock_version when updating an existing connection (from +get_ai_monitor_connection); omit on first create"
+    }
+  ],
+  risk: "write",
+  dryRun: (ctx) => evalDryRun(ctx, "PUT", PATH82, void 0, redactedDryRunBody(ctx)),
+  execute: async (ctx) => evalApi(ctx, "PUT", PATH82, void 0, buildBody35(ctx))
+};
+
+// src/commands/evaluation/verify-ai-monitor-connection.ts
+var PATH83 = "/ai-monitor-connection/verify";
+var verifyAiMonitorConnection = {
+  service: "evaluation",
+  command: "+verify_ai_monitor_connection",
+  description: "Verify the saved AI Monitor connection by reaching the upstream via POST /agenteval/api/v1/ai-monitor-connection/verify. Sends no request body; returns the upstream trace total.",
+  flags: [...evalFlags()],
+  risk: "read",
+  dryRun: (ctx) => evalDryRun(ctx, "POST", PATH83),
+  execute: async (ctx) => evalApi(ctx, "POST", PATH83)
+};
+
+// src/commands/evaluation/import-ai-monitor-traces.ts
+var PATH84 = "/datasets/ai-monitor-imports";
+function buildBody36(ctx) {
+  const body = { name: ctx.str("name") };
+  const description = ctx.str("description");
+  if (description) body.description = description;
+  const selection = ctx.json("selection-json");
+  if (selection === null || typeof selection !== "object" || Array.isArray(selection)) {
+    throw new Error("--selection-json must be a JSON object");
+  }
+  const mode = selection.mode;
+  if (mode !== "FILTER" && mode !== "TRACE_IDS") {
+    throw new Error("--selection-json mode must be FILTER or TRACE_IDS");
+  }
+  if (mode === "FILTER") {
+    const startTime = selection.start_time;
+    const endTime = selection.end_time;
+    const isDate = (value) => {
+      if (typeof value !== "string" || !/^\d{4}-\d{2}-\d{2}$/.test(value)) return false;
+      const timestamp = Date.parse(`${value}T00:00:00Z`);
+      return !Number.isNaN(timestamp) && new Date(timestamp).toISOString().slice(0, 10) === value;
+    };
+    if (!isDate(startTime) || !isDate(endTime)) {
+      throw new Error("--selection-json with mode FILTER requires start_time and end_time as YYYY-MM-DD dates");
+    }
+    if (Date.parse(`${startTime}T00:00:00Z`) > Date.parse(`${endTime}T00:00:00Z`)) {
+      throw new Error("--selection-json end_time must not precede start_time");
+    }
+  }
+  if (mode === "TRACE_IDS") {
+    const traceIds = selection.trace_ids;
+    if (!Array.isArray(traceIds) || traceIds.length < 1 || traceIds.length > 1e3 || !traceIds.every((v) => typeof v === "string")) {
+      throw new Error("--selection-json with mode TRACE_IDS requires trace_ids: 1-1000 strings");
+    }
+  }
+  body.selection = selection;
+  return body;
+}
+var importAiMonitorTraces = {
+  service: "evaluation",
+  command: "+import_ai_monitor_traces",
+  description: "Create a dataset import job from AI Monitor traces via POST /agenteval/api/v1/datasets/ai-monitor-imports. Returns the created dataset and import job; the import is asynchronous, so poll +dataset_import_status with the returned dataset id instead of treating the 201 as completion.",
+  flags: [
+    ...evalFlags(),
+    { name: "name", type: "string", required: true, desc: "Target dataset name (max 128 chars)" },
+    { name: "description", type: "string", desc: "Optional dataset description (max 2000 chars)" },
+    {
+      name: "selection-json",
+      type: "json",
+      required: true,
+      sensitive: true,
+      desc: 'Import selection JSON (redacted from logs): {"mode":"FILTER","start_time":"YYYY-MM-DD","end_time":"YYYY-MM-DD"} (dates required, optional agent, channel, search_term) or {"mode":"TRACE_IDS","trace_ids":["<id>"]} (1-1000 ids)'
+    },
+    {
+      name: "idempotency-key",
+      type: "string",
+      desc: "Optional Idempotency-Key header (max 191 chars) for duplicate-import protection"
+    }
+  ],
+  risk: "write",
+  dryRun: (ctx) => evalDryRun(ctx, "POST", PATH84, void 0, buildBody36(ctx), {
+    idempotencyKey: ctx.str("idempotency-key") || void 0
+  }),
+  execute: async (ctx) => evalApi(ctx, "POST", PATH84, void 0, buildBody36(ctx), {
+    idempotencyKey: ctx.str("idempotency-key") || void 0
+  })
+};
+
+// src/commands/evaluation/list-te-claude-catalog.ts
+var PATH85 = "/agents/te-claude/catalog";
+function buildBody37(ctx) {
+  const body = { endpoint_url: ctx.str("endpoint-url") };
+  const credentialId = ctx.str("credential-id");
+  if (credentialId) body.credential_id = credentialId;
+  return body;
+}
+var listTeClaudeCatalog = {
+  service: "evaluation",
+  command: "+list_te_claude_catalog",
+  description: "List TE Claude agents and models via POST /agenteval/api/v1/agents/te-claude/catalog. TE sessions use the login access token automatically; non-TE authentication may provide a legacy credential. Use the returned ids when creating TE_CLAUDE_WEB model configs and agent configs.",
+  flags: [
+    ...evalFlags(),
+    { name: "endpoint-url", type: "string", required: true, desc: "TE Claude endpoint URL (absolute URI)" },
+    {
+      name: "credential-id",
+      type: "string",
+      desc: "Optional legacy credential UUID for non-TE authentication; TE sessions use the login access token automatically"
+    }
+  ],
+  risk: "read",
+  dryRun: (ctx) => evalDryRun(ctx, "POST", PATH85, void 0, buildBody37(ctx)),
+  execute: async (ctx) => evalApi(ctx, "POST", PATH85, void 0, buildBody37(ctx))
+};
+
+// src/commands/evaluation/list-project-members.ts
+var PATH86 = "/projects/members";
+var listProjectMembers = {
+  service: "evaluation",
+  command: "+list_project_members",
+  description: "List project members via GET /agenteval/api/v1/projects/members. Requires ADMIN role. Includes external_id, login status and root | agent_admin | member role. Use the returned user UUIDs as --owner-user-id for +transfer_run_owner and other transfer commands.",
+  flags: [...evalFlags()],
+  risk: "read",
+  dryRun: (ctx) => evalDryRun(ctx, "GET", PATH86),
+  execute: async (ctx) => evalApi(ctx, "GET", PATH86)
+};
+
+// src/commands/evaluation/list-model-configs.ts
+var PATH87 = "/model-configs";
+var listModelConfigs = {
+  service: "evaluation",
+  command: "+list_model_configs",
+  description: "List model configurations via GET /agenteval/api/v1/model-configs. Returns all model configs (LLM judge backends).",
+  flags: [...evalFlags()],
+  risk: "read",
+  dryRun: (ctx) => evalDryRun(ctx, "GET", PATH87),
+  execute: async (ctx) => evalApi(ctx, "GET", PATH87)
+};
+
+// src/commands/evaluation/get-model-config.ts
+var PATH88 = "/model-configs";
+function pathFor67(ctx) {
+  return `${PATH88}/${evalPathId(ctx, "id")}`;
+}
+var getModelConfig = {
+  service: "evaluation",
+  command: "+get_model_config",
+  description: "Get one model configuration by id via GET /agenteval/api/v1/model-configs/{modelConfigId}.",
+  flags: [...evalFlags(), idFlag("Model config UUID")],
+  risk: "read",
+  dryRun: (ctx) => evalDryRun(ctx, "GET", pathFor67(ctx)),
+  execute: async (ctx) => evalApi(ctx, "GET", pathFor67(ctx))
+};
+
+// src/commands/evaluation/create-model-config.ts
+var PATH89 = "/model-configs";
+function buildBody38(ctx) {
+  const body = {
+    name: ctx.str("name"),
+    provider: ctx.str("provider"),
+    model_name: ctx.str("model-name"),
+    base_url: ctx.str("base-url")
+  };
+  const parameters = ctx.json("parameters-json");
+  if (parameters !== void 0) body.parameters = parameters;
+  const capabilities = ctx.json("capabilities-json");
+  if (capabilities !== void 0) body.capabilities = capabilities;
+  const credentialId = ctx.str("credential-id");
+  if (credentialId) body.credential_id = credentialId;
+  return body;
+}
+var createModelConfig = {
+  service: "evaluation",
+  command: "+create_model_config",
+  description: "Create an LLM model configuration via POST /agenteval/api/v1/model-configs. Capabilities must set chat_completions=true and max_context_tokens>=1. Validate reachability with +test_model_config_connectivity before use. Creates a personal resource; sharing and administrative operations use separate permission checks.",
+  flags: [
+    ...evalFlags(),
+    { name: "name", type: "string", required: true, desc: "Model config name (1-128 characters)" },
+    {
+      name: "provider",
+      type: "string",
+      required: true,
+      desc: "Provider protocol: OPENAI_COMPATIBLE_CHAT | ANTHROPIC_CHAT | GEMINI_CHAT | AZURE_OPENAI_CHAT | TE_CLAUDE_WEB"
+    },
+    { name: "model-name", type: "string", required: true, desc: "Model name sent to the provider (1-128 characters)" },
+    { name: "base-url", type: "string", required: true, desc: "Provider base URL; /v1 is appended automatically per provider convention" },
+    {
+      name: "parameters-json",
+      type: "json",
+      desc: "ModelParameters JSON (MODEL_PARAMETERS_V2: temperature/top_p/seed/timeout_ms/max_retries/structured_output); output limits are delegated to the provider"
+    },
+    {
+      name: "capabilities-json",
+      type: "json",
+      desc: "ModelCapabilities JSON (schema_version/chat_completions/json_schema/seed/usage/max_context_tokens), MODEL_CAPABILITIES_V1"
+    },
+    {
+      name: "credential-id",
+      type: "string",
+      desc: "Credential UUID from +list_credentials; TE_CLAUDE_WEB under TE authentication binds the login credential automatically"
+    }
+  ],
+  risk: "write",
+  dryRun: (ctx) => evalDryRun(ctx, "POST", PATH89, void 0, buildBody38(ctx)),
+  execute: async (ctx) => evalApi(ctx, "POST", PATH89, void 0, buildBody38(ctx))
+};
+
+// src/commands/evaluation/update-model-config.ts
+var PATH90 = "/model-configs";
+function pathFor68(ctx) {
+  return `${PATH90}/${evalPathId(ctx, "id")}`;
+}
+function buildBody39(ctx) {
+  const body = {
+    name: ctx.str("name"),
+    provider: ctx.str("provider"),
+    model_name: ctx.str("model-name"),
+    base_url: ctx.str("base-url"),
+    lock_version: ctx.num("lock-version")
+  };
+  const parameters = ctx.json("parameters-json");
+  if (parameters !== void 0) body.parameters = parameters;
+  const capabilities = ctx.json("capabilities-json");
+  if (capabilities !== void 0) body.capabilities = capabilities;
+  const credentialId = ctx.str("credential-id");
+  if (credentialId) body.credential_id = credentialId;
+  return body;
+}
+var updateModelConfig = {
+  service: "evaluation",
+  command: "+update_model_config",
+  description: "Update a model configuration via PATCH /agenteval/api/v1/model-configs/{id}. Full-replace semantics: pass every field, not only the ones changing (e.g. raise timeout_ms inside --parameters-json). Requires the current lock_version from +get_model_config.",
+  flags: [
+    ...evalFlags(),
+    ...idAndLockFlags("Model config UUID", "model config"),
+    { name: "name", type: "string", required: true, desc: "Model config name (1-128 characters)" },
+    {
+      name: "provider",
+      type: "string",
+      required: true,
+      desc: "Provider protocol: OPENAI_COMPATIBLE_CHAT | ANTHROPIC_CHAT | GEMINI_CHAT | AZURE_OPENAI_CHAT | TE_CLAUDE_WEB"
+    },
+    { name: "model-name", type: "string", required: true, desc: "Model name sent to the provider" },
+    { name: "base-url", type: "string", required: true, desc: "Provider base URL" },
+    {
+      name: "parameters-json",
+      type: "json",
+      desc: "ModelParameters JSON (MODEL_PARAMETERS_V2), e.g. temperature/top_p/seed/timeout_ms/max_retries; output limits are provider-controlled"
+    },
+    {
+      name: "capabilities-json",
+      type: "json",
+      desc: "ModelCapabilities JSON (MODEL_CAPABILITIES_V1); chat_completions=true and max_context_tokens>=1 are required"
+    },
+    {
+      name: "credential-id",
+      type: "string",
+      desc: "Credential UUID used to authenticate to the provider; TE_CLAUDE_WEB under TE authentication binds the login credential automatically"
+    }
+  ],
+  risk: "write",
+  dryRun: (ctx) => evalDryRun(ctx, "PATCH", pathFor68(ctx), void 0, buildBody39(ctx)),
+  execute: async (ctx) => evalApi(ctx, "PATCH", pathFor68(ctx), void 0, buildBody39(ctx))
+};
+
+// src/commands/evaluation/delete-model-config.ts
+var PATH91 = "/model-configs";
+function pathFor69(ctx) {
+  return `${PATH91}/${evalPathId(ctx, "id")}`;
+}
+function buildBody40(ctx) {
+  return { lock_version: ctx.num("lock-version") };
+}
+var deleteModelConfig = {
+  service: "evaluation",
+  command: "+delete_model_config",
+  description: "Delete a model configuration via DELETE /agenteval/api/v1/model-configs/{id}. Evaluators and run templates referencing it are unaffected (frozen snapshots) but new bindings fail. Requires the current lock_version.",
+  flags: [...evalFlags(), ...idAndLockFlags("Model config UUID", "model config")],
+  risk: "high-risk-write",
+  dryRun: (ctx) => evalDryRun(ctx, "DELETE", pathFor69(ctx), void 0, buildBody40(ctx)),
+  execute: async (ctx) => evalApi(ctx, "DELETE", pathFor69(ctx), void 0, buildBody40(ctx))
+};
+
+// src/commands/evaluation/test-model-config-connectivity.ts
+var PATH92 = "/model-configs";
+function pathFor70(ctx) {
+  return `${PATH92}/${evalPathId(ctx, "id")}/test-connectivity`;
+}
+var testModelConfigConnectivity = {
+  service: "evaluation",
+  command: "+test_model_config_connectivity",
+  description: "Probe a model configuration with a minimal chat request via POST /agenteval/api/v1/model-configs/{id}/test-connectivity. Verifies base URL, credential, and model name before the config is used by evaluators or runs.",
+  flags: [...evalFlags(), idFlag("Model config UUID")],
+  risk: "read",
+  dryRun: (ctx) => evalDryRun(ctx, "POST", pathFor70(ctx)),
+  execute: async (ctx) => evalApi(ctx, "POST", pathFor70(ctx))
+};
+
+// src/commands/evaluation/transfer-model-config-owner.ts
+var PATH93 = "/model-configs";
+function pathFor71(ctx) {
+  return `${PATH93}/${evalPathId(ctx, "id")}/transfer-owner`;
+}
+function buildBody41(ctx) {
+  return { owner_user_id: ctx.str("owner-user-id"), lock_version: ctx.num("lock-version") };
+}
+var transferModelConfigOwner = {
+  service: "evaluation",
+  command: "+transfer_model_config_owner",
+  description: "Transfer model config ownership to another user via POST /agenteval/api/v1/model-configs/{id}/transfer-owner. Changes resource permissions; requires ADMIN role and the current model config lock_version.",
+  flags: [
+    ...evalFlags(),
+    ...idAndLockFlags("Model config UUID", "model config"),
+    { name: "owner-user-id", type: "string", required: true, desc: "User UUID of the new owner" }
+  ],
+  risk: "high-risk-write",
+  dryRun: (ctx) => evalDryRun(ctx, "POST", pathFor71(ctx), void 0, buildBody41(ctx)),
+  execute: async (ctx) => evalApi(ctx, "POST", pathFor71(ctx), void 0, buildBody41(ctx))
+};
+
+// src/commands/evaluation/list-agents.ts
+var PATH94 = "/agents";
+var listAgents = {
+  service: "evaluation",
+  command: "+list_agents",
+  description: "List agents under test via GET /agenteval/api/v1/agents. Returns all configured agent connectors.",
+  flags: [...evalFlags()],
+  risk: "read",
+  dryRun: (ctx) => evalDryRun(ctx, "GET", PATH94),
+  execute: async (ctx) => evalApi(ctx, "GET", PATH94)
+};
+
+// src/commands/evaluation/get-agent.ts
+var PATH95 = "/agents";
+function pathFor72(ctx) {
+  return `${PATH95}/${evalPathId(ctx, "id")}`;
+}
+var getAgent = {
+  service: "evaluation",
+  command: "+get_agent",
+  description: "Get one agent configuration by id via GET /agenteval/api/v1/agents/{agentId}.",
+  flags: [...evalFlags(), idFlag("Agent UUID")],
+  risk: "read",
+  dryRun: (ctx) => evalDryRun(ctx, "GET", pathFor72(ctx)),
+  execute: async (ctx) => evalApi(ctx, "GET", pathFor72(ctx))
+};
+
+// src/commands/evaluation/create-agent.ts
+var PATH96 = "/agents";
+function buildBody42(ctx) {
+  const body = {
+    name: ctx.str("name"),
+    endpoint_url: ctx.str("endpoint-url"),
+    input_schema: ctx.json("input-schema-json"),
+    config: ctx.json("config-json")
+  };
+  const connectorType = ctx.str("connector-type");
+  if (connectorType) body.connector_type = connectorType;
+  const credentialId = ctx.str("credential-id");
+  if (credentialId) body.credential_id = credentialId;
+  return body;
+}
+function validateBody(body) {
+  if (typeof body.input_schema !== "object" || body.input_schema === null) {
+    throw new Error("--input-schema-json is required (AGENT_INPUT_SCHEMA_V1 object with type/properties/required)");
+  }
+  if (typeof body.config !== "object" || body.config === null) {
+    throw new Error("--config-json is required (AGENT_CONFIG_V* object matching the connector type)");
+  }
+}
+var createAgent = {
+  service: "evaluation",
+  command: "+create_agent",
+  description: "Create an agent under test via POST /agenteval/api/v1/agents. Validate reachability with +test_agent_connectivity before binding the agent to runs. Creates a personal resource; sharing and administrative operations use separate permission checks.",
+  flags: [
+    ...evalFlags(),
+    { name: "name", type: "string", required: true, desc: "Agent config name (1-128 characters)" },
+    {
+      name: "connector-type",
+      type: "string",
+      desc: "Connector protocol: HTTP_JSON_V1 | OPENCODE_SERVER | OPENCLAW_GATEWAY_V1 | HERMES_RUNS_V1 | TE_CLAUDE_WEB_V1"
+    },
+    { name: "endpoint-url", type: "string", required: true, desc: "Agent endpoint URL (max 1000 characters)" },
+    {
+      name: "input-schema-json",
+      type: "json",
+      required: true,
+      desc: 'AgentInputSchema JSON (AGENT_INPUT_SCHEMA_V1): {"type":"object","properties":{...},"required":[...]}'
+    },
+    {
+      name: "config-json",
+      type: "json",
+      required: true,
+      desc: "AgentConfig JSON (AGENT_CONFIG_V*) matching the connector type; see an existing agent via +get_agent for a template"
+    },
+    {
+      name: "credential-id",
+      type: "string",
+      desc: "Credential UUID from +list_credentials; TE_CLAUDE_WEB_V1 under TE authentication binds the login credential automatically"
+    }
+  ],
+  risk: "write",
+  dryRun: (ctx) => {
+    const body = buildBody42(ctx);
+    validateBody(body);
+    return evalDryRun(ctx, "POST", PATH96, void 0, body);
+  },
+  execute: async (ctx) => {
+    const body = buildBody42(ctx);
+    validateBody(body);
+    return evalApi(ctx, "POST", PATH96, void 0, body);
+  }
+};
+
+// src/commands/evaluation/update-agent.ts
+var PATH97 = "/agents";
+function pathFor73(ctx) {
+  return `${PATH97}/${evalPathId(ctx, "id")}`;
+}
+function buildBody43(ctx) {
+  const body = {
+    name: ctx.str("name"),
+    endpoint_url: ctx.str("endpoint-url"),
+    input_schema: ctx.json("input-schema-json"),
+    config: ctx.json("config-json"),
+    lock_version: ctx.num("lock-version")
+  };
+  const connectorType = ctx.str("connector-type");
+  if (connectorType) body.connector_type = connectorType;
+  const credentialId = ctx.str("credential-id");
+  if (credentialId) body.credential_id = credentialId;
+  return body;
+}
+function validateBody2(body) {
+  if (typeof body.input_schema !== "object" || body.input_schema === null) {
+    throw new Error("--input-schema-json is required (AGENT_INPUT_SCHEMA_V1 object)");
+  }
+  if (typeof body.config !== "object" || body.config === null) {
+    throw new Error("--config-json is required (AGENT_CONFIG_V* object matching the connector type)");
+  }
+}
+var updateAgent = {
+  service: "evaluation",
+  command: "+update_agent",
+  description: "Update an agent under test via PATCH /agenteval/api/v1/agents/{id}. Full-replace semantics: pass every field including unchanged ones. Requires the current agent lock_version from +get_agent.",
+  flags: [
+    ...evalFlags(),
+    ...idAndLockFlags("Agent UUID", "agent"),
+    { name: "name", type: "string", required: true, desc: "Agent config name (1-128 characters)" },
+    {
+      name: "connector-type",
+      type: "string",
+      desc: "Connector protocol: HTTP_JSON_V1 | OPENCODE_SERVER | OPENCLAW_GATEWAY_V1 | HERMES_RUNS_V1 | TE_CLAUDE_WEB_V1"
+    },
+    { name: "endpoint-url", type: "string", required: true, desc: "Agent endpoint URL (max 1000 characters)" },
+    { name: "input-schema-json", type: "json", required: true, desc: "AgentInputSchema JSON (AGENT_INPUT_SCHEMA_V1)" },
+    { name: "config-json", type: "json", required: true, desc: "AgentConfig JSON (AGENT_CONFIG_V*) matching the connector type" },
+    {
+      name: "credential-id",
+      type: "string",
+      desc: "Credential UUID used to authenticate to the agent; TE_CLAUDE_WEB_V1 under TE authentication binds the login credential automatically"
+    }
+  ],
+  risk: "write",
+  dryRun: (ctx) => {
+    const body = buildBody43(ctx);
+    validateBody2(body);
+    return evalDryRun(ctx, "PATCH", pathFor73(ctx), void 0, body);
+  },
+  execute: async (ctx) => {
+    const body = buildBody43(ctx);
+    validateBody2(body);
+    return evalApi(ctx, "PATCH", pathFor73(ctx), void 0, body);
+  }
+};
+
+// src/commands/evaluation/delete-agent.ts
+var PATH98 = "/agents";
+function pathFor74(ctx) {
+  return `${PATH98}/${evalPathId(ctx, "id")}`;
+}
+function buildBody44(ctx) {
+  return { lock_version: ctx.num("lock-version") };
+}
+var deleteAgent = {
+  service: "evaluation",
+  command: "+delete_agent",
+  description: "Delete an agent under test via DELETE /agenteval/api/v1/agents/{id}. Runs referencing the agent keep their frozen snapshot. Requires the current agent lock_version.",
+  flags: [...evalFlags(), ...idAndLockFlags("Agent UUID", "agent")],
+  risk: "high-risk-write",
+  dryRun: (ctx) => evalDryRun(ctx, "DELETE", pathFor74(ctx), void 0, buildBody44(ctx)),
+  execute: async (ctx) => evalApi(ctx, "DELETE", pathFor74(ctx), void 0, buildBody44(ctx))
+};
+
+// src/commands/evaluation/test-agent-connectivity.ts
+var PATH99 = "/agents";
+function pathFor75(ctx) {
+  return `${PATH99}/${evalPathId(ctx, "id")}/test-connectivity`;
+}
+var testAgentConnectivity = {
+  service: "evaluation",
+  command: "+test_agent_connectivity",
+  description: "Run a compatibility preflight against an agent via POST /agenteval/api/v1/agents/{id}/test-connectivity: connection, authentication, and protocol version. Fix any reported issue before starting runs.",
+  flags: [...evalFlags(), idFlag("Agent UUID")],
+  risk: "read",
+  dryRun: (ctx) => evalDryRun(ctx, "POST", pathFor75(ctx)),
+  execute: async (ctx) => evalApi(ctx, "POST", pathFor75(ctx))
+};
+
+// src/commands/evaluation/agent-snapshot-preview.ts
+var PATH100 = "/agents";
+function pathFor76(ctx) {
+  return `${PATH100}/${evalPathId(ctx, "id")}/snapshot-preview`;
+}
+var agentSnapshotPreview = {
+  service: "evaluation",
+  command: "+agent_snapshot_preview",
+  description: "Preview the immutable agent snapshot a run would freeze at start via GET /agenteval/api/v1/agents/{id}/snapshot-preview. Use to verify what a run template actually captured.",
+  flags: [...evalFlags(), idFlag("Agent UUID")],
+  risk: "read",
+  dryRun: (ctx) => evalDryRun(ctx, "GET", pathFor76(ctx)),
+  execute: async (ctx) => evalApi(ctx, "GET", pathFor76(ctx))
+};
+
+// src/commands/evaluation/transfer-agent-owner.ts
+var PATH101 = "/agents";
+function pathFor77(ctx) {
+  return `${PATH101}/${evalPathId(ctx, "id")}/transfer-owner`;
+}
+function buildBody45(ctx) {
+  return { owner_user_id: ctx.str("owner-user-id"), lock_version: ctx.num("lock-version") };
+}
+var transferAgentOwner = {
+  service: "evaluation",
+  command: "+transfer_agent_owner",
+  description: "Transfer agent ownership to another user via POST /agenteval/api/v1/agents/{id}/transfer-owner. Changes resource permissions; requires ADMIN role and the current agent lock_version.",
+  flags: [
+    ...evalFlags(),
+    ...idAndLockFlags("Agent UUID", "agent"),
+    { name: "owner-user-id", type: "string", required: true, desc: "User UUID of the new owner" }
+  ],
+  risk: "high-risk-write",
+  dryRun: (ctx) => evalDryRun(ctx, "POST", pathFor77(ctx), void 0, buildBody45(ctx)),
+  execute: async (ctx) => evalApi(ctx, "POST", pathFor77(ctx), void 0, buildBody45(ctx))
+};
+
+// src/commands/evaluation/list-credentials.ts
+var PATH102 = "/credentials";
+var listCredentials = {
+  service: "evaluation",
+  command: "+list_credentials",
+  description: "List platform credentials via GET /agenteval/api/v1/credentials. Secrets are never returned; use +get_credential for one entry. Requires ADMIN role.",
+  flags: [...evalFlags()],
+  risk: "read",
+  dryRun: (ctx) => evalDryRun(ctx, "GET", PATH102),
+  execute: async (ctx) => evalApi(ctx, "GET", PATH102)
+};
+
+// src/commands/evaluation/get-credential.ts
+var PATH103 = "/credentials";
+function pathFor78(ctx) {
+  return `${PATH103}/${evalPathId(ctx, "id")}`;
+}
+var getCredential = {
+  service: "evaluation",
+  command: "+get_credential",
+  description: "Get one credential by UUID via GET /agenteval/api/v1/credentials/{id}. The secret value is never returned. Requires ADMIN role.",
+  flags: [...evalFlags(), idFlag("Credential UUID")],
+  risk: "read",
+  dryRun: (ctx) => evalDryRun(ctx, "GET", pathFor78(ctx)),
+  execute: async (ctx) => evalApi(ctx, "GET", pathFor78(ctx))
+};
+
+// src/commands/evaluation/create-credential.ts
+var PATH104 = "/credentials";
+var CREDENTIAL_TYPES = ["BEARER_TOKEN", "API_KEY_HEADER", "AI_MONITOR_SESSION"];
+function buildBody46(ctx) {
+  const type = ctx.str("type");
+  if (!CREDENTIAL_TYPES.includes(type)) {
+    throw new Error("--type must be one of BEARER_TOKEN | API_KEY_HEADER | AI_MONITOR_SESSION");
+  }
+  const body = {
+    name: ctx.str("name"),
+    type,
+    secret: ctx.str("secret")
+  };
+  const header = ctx.str("header-name");
+  if (header) body.header_name = header;
+  const dataToken = ctx.str("data-token");
+  const reportSource = ctx.str("report-source");
+  if (type === "AI_MONITOR_SESSION") {
+    if (!dataToken || !reportSource) {
+      throw new Error("--data-token and --report-source are required for AI_MONITOR_SESSION credentials");
+    }
+    body.data_token = dataToken;
+    body.report_source = reportSource;
+  } else if (dataToken || reportSource) {
+    throw new Error("--data-token / --report-source are only supported for AI_MONITOR_SESSION credentials");
+  }
+  return body;
+}
+function redactedDryRunBody2(ctx) {
+  const body = buildBody46(ctx);
+  const redacted = { ...body };
+  if (typeof redacted.secret === "string" && redacted.secret) redacted.secret = "***redacted***";
+  if (typeof redacted.data_token === "string" && redacted.data_token) redacted.data_token = "***redacted***";
+  if (typeof redacted.report_source === "string" && redacted.report_source) redacted.report_source = "***redacted***";
+  return redacted;
+}
+var createCredential = {
+  service: "evaluation",
+  command: "+create_credential",
+  description: "Create a credential via POST /agenteval/api/v1/credentials. The secret is stored server-side and never echoed back; reference the credential by UUID when creating model configs, agents, or AI Monitor connections. Requires ADMIN role.",
+  flags: [
+    ...evalFlags(),
+    { name: "name", type: "string", required: true, desc: "Credential name (1-128 characters)" },
+    {
+      name: "type",
+      type: "string",
+      required: true,
+      desc: "Credential type: BEARER_TOKEN | API_KEY_HEADER | AI_MONITOR_SESSION"
+    },
+    {
+      name: "secret",
+      type: "string",
+      required: true,
+      sensitive: true,
+      desc: "Secret value (max 8192 chars); sent once to the current AE Host and never returned by the platform"
+    },
+    { name: "header-name", type: "string", desc: "Header name for API_KEY_HEADER credentials (max 64 chars)" },
+    {
+      name: "data-token",
+      type: "string",
+      sensitive: true,
+      desc: "AI Monitor data token (max 512 chars); required for AI_MONITOR_SESSION credentials"
+    },
+    {
+      name: "report-source",
+      type: "string",
+      sensitive: true,
+      desc: "AI Monitor report source (max 128 chars); required for AI_MONITOR_SESSION credentials"
+    }
+  ],
+  risk: "write",
+  dryRun: (ctx) => evalDryRun(ctx, "POST", PATH104, void 0, redactedDryRunBody2(ctx)),
+  execute: async (ctx) => evalApi(ctx, "POST", PATH104, void 0, buildBody46(ctx))
+};
+
+// src/commands/evaluation/update-credential.ts
+var PATH105 = "/credentials";
+function pathFor79(ctx) {
+  return `${PATH105}/${evalPathId(ctx, "id")}`;
+}
+function buildBody47(ctx) {
+  return { name: ctx.str("name"), lock_version: ctx.num("lock-version") };
+}
+var updateCredential = {
+  service: "evaluation",
+  command: "+update_credential",
+  description: "Rename a credential via PATCH /agenteval/api/v1/credentials/{id}. To replace the secret use +rotate_credential. Requires the current credential lock_version.",
+  flags: [
+    ...evalFlags(),
+    ...idAndLockFlags("Credential UUID", "credential"),
+    { name: "name", type: "string", required: true, desc: "New credential name (1-128 characters)" }
+  ],
+  risk: "write",
+  dryRun: (ctx) => evalDryRun(ctx, "PATCH", pathFor79(ctx), void 0, buildBody47(ctx)),
+  execute: async (ctx) => evalApi(ctx, "PATCH", pathFor79(ctx), void 0, buildBody47(ctx))
+};
+
+// src/commands/evaluation/rotate-credential.ts
+var PATH106 = "/credentials";
+function pathFor80(ctx) {
+  return `${PATH106}/${evalPathId(ctx, "id")}/rotate`;
+}
+function buildBody48(ctx) {
+  return { secret: ctx.str("secret"), lock_version: ctx.num("lock-version") };
+}
+var rotateCredential = {
+  service: "evaluation",
+  command: "+rotate_credential",
+  description: "Replace the secret of a credential via POST /agenteval/api/v1/credentials/{id}/rotate. Model configs and agents referencing it pick up the new secret on their next call. Requires the current credential lock_version.",
+  flags: [
+    ...evalFlags(),
+    ...idAndLockFlags("Credential UUID", "credential"),
+    {
+      name: "secret",
+      type: "string",
+      required: true,
+      sensitive: true,
+      desc: "New secret value (max 8192 chars); sent once to the current AE Host and never returned by the platform"
+    }
+  ],
+  risk: "write",
+  dryRun: (ctx) => evalDryRun(ctx, "POST", pathFor80(ctx), void 0, { secret: "***redacted***", lock_version: ctx.num("lock-version") }),
+  execute: async (ctx) => evalApi(ctx, "POST", pathFor80(ctx), void 0, buildBody48(ctx))
+};
+
+// src/commands/evaluation/disable-credential.ts
+var PATH107 = "/credentials";
+function pathFor81(ctx) {
+  return `${PATH107}/${evalPathId(ctx, "id")}/disable`;
+}
+function buildBody49(ctx) {
+  return { lock_version: ctx.num("lock-version") };
+}
+var disableCredential = {
+  service: "evaluation",
+  command: "+disable_credential",
+  description: "Disable a credential via POST /agenteval/api/v1/credentials/{id}/disable. Disabled credentials fail connectivity and are rejected for new bindings. Requires the current credential lock_version.",
+  flags: [...evalFlags(), ...idAndLockFlags("Credential UUID", "credential")],
+  risk: "high-risk-write",
+  dryRun: (ctx) => evalDryRun(ctx, "POST", pathFor81(ctx), void 0, buildBody49(ctx)),
+  execute: async (ctx) => evalApi(ctx, "POST", pathFor81(ctx), void 0, buildBody49(ctx))
+};
+
+// src/commands/evaluation/enable-credential.ts
+var PATH108 = "/credentials";
+function pathFor82(ctx) {
+  return `${PATH108}/${evalPathId(ctx, "id")}/enable`;
+}
+function buildBody50(ctx) {
+  return { lock_version: ctx.num("lock-version") };
+}
+var enableCredential = {
+  service: "evaluation",
+  command: "+enable_credential",
+  description: "Re-enable a disabled credential via POST /agenteval/api/v1/credentials/{id}/enable. Requires the current credential lock_version.",
+  flags: [...evalFlags(), ...idAndLockFlags("Credential UUID", "credential")],
+  risk: "high-risk-write",
+  dryRun: (ctx) => evalDryRun(ctx, "POST", pathFor82(ctx), void 0, buildBody50(ctx)),
+  execute: async (ctx) => evalApi(ctx, "POST", pathFor82(ctx), void 0, buildBody50(ctx))
+};
+
+// src/commands/evaluation/delete-credential.ts
+var PATH109 = "/credentials";
+function pathFor83(ctx) {
+  return `${PATH109}/${evalPathId(ctx, "id")}`;
+}
+function buildBody51(ctx) {
+  return { lock_version: ctx.num("lock-version") };
+}
+var deleteCredential = {
+  service: "evaluation",
+  command: "+delete_credential",
+  description: "Delete a credential via DELETE /agenteval/api/v1/credentials/{id}. Model configs and agents still referencing it will fail until rebound. Requires the current credential lock_version.",
+  flags: [...evalFlags(), ...idAndLockFlags("Credential UUID", "credential")],
+  risk: "high-risk-write",
+  dryRun: (ctx) => evalDryRun(ctx, "DELETE", pathFor83(ctx), void 0, buildBody51(ctx)),
+  execute: async (ctx) => evalApi(ctx, "DELETE", pathFor83(ctx), void 0, buildBody51(ctx))
+};
+
+// src/commands/evaluation/transfer-credential-owner.ts
+var PATH110 = "/credentials";
+function pathFor84(ctx) {
+  return `${PATH110}/${evalPathId(ctx, "id")}/transfer-owner`;
+}
+function buildBody52(ctx) {
+  return { owner_user_id: ctx.str("owner-user-id"), lock_version: ctx.num("lock-version") };
+}
+var transferCredentialOwner = {
+  service: "evaluation",
+  command: "+transfer_credential_owner",
+  description: "Transfer credential ownership to another user via POST /agenteval/api/v1/credentials/{id}/transfer-owner. Changes resource permissions; requires ADMIN role and the current credential lock_version.",
+  flags: [
+    ...evalFlags(),
+    ...idAndLockFlags("Credential UUID", "credential"),
+    { name: "owner-user-id", type: "string", required: true, desc: "User UUID of the new owner" }
+  ],
+  risk: "high-risk-write",
+  dryRun: (ctx) => evalDryRun(ctx, "POST", pathFor84(ctx), void 0, buildBody52(ctx)),
+  execute: async (ctx) => evalApi(ctx, "POST", pathFor84(ctx), void 0, buildBody52(ctx))
+};
+
+// src/commands/evaluation/change-dataset-access-scope.ts
+function pathFor85(ctx) {
+  return `/datasets/${evalPathId(ctx, "id")}/access-scope`;
+}
+function buildBody53(ctx) {
+  const accessScope = ctx.str("access-scope");
+  if (!["PERSONAL", "COMPANY"].includes(accessScope)) {
+    throw new CliValidationError("--access-scope must be PERSONAL or COMPANY");
+  }
+  return { access_scope: accessScope, lock_version: ctx.num("lock-version") };
+}
+var changeDatasetAccessScope = {
+  service: "evaluation",
+  resource: "dataset",
+  command: "access-scope",
+  description: "Change dataset visibility within the current project. Requires an administrator and the current lock_version. COMPANY assets cannot depend on private configurations or credentials.",
+  flags: [
+    ...evalFlags(),
+    ...idAndLockFlags("Dataset UUID", "dataset"),
+    { name: "access-scope", type: "string", required: true, pattern: "^(PERSONAL|COMPANY)$", desc: "Target visibility: PERSONAL | COMPANY; SYSTEM is read-only" }
+  ],
+  risk: "high-risk-write",
+  preflight: (ctx) => {
+    buildBody53(ctx);
+  },
+  dryRun: (ctx) => evalDryRun(ctx, "PATCH", pathFor85(ctx), void 0, buildBody53(ctx)),
+  execute: async (ctx) => evalApi(ctx, "PATCH", pathFor85(ctx), void 0, buildBody53(ctx))
+};
+
+// src/commands/evaluation/change-evaluator-access-scope.ts
+function pathFor86(ctx) {
+  return `/evaluators/${evalPathId(ctx, "id")}/access-scope`;
+}
+function buildBody54(ctx) {
+  const accessScope = ctx.str("access-scope");
+  if (!["PERSONAL", "COMPANY"].includes(accessScope)) {
+    throw new CliValidationError("--access-scope must be PERSONAL or COMPANY");
+  }
+  return { access_scope: accessScope, lock_version: ctx.num("lock-version") };
+}
+var changeEvaluatorAccessScope = {
+  service: "evaluation",
+  resource: "evaluator",
+  command: "access-scope",
+  description: "Change evaluator visibility within the current project. Requires an administrator and the current lock_version. COMPANY assets cannot depend on private configurations or credentials.",
+  flags: [
+    ...evalFlags(),
+    ...idAndLockFlags("Evaluator UUID", "evaluator"),
+    { name: "access-scope", type: "string", required: true, pattern: "^(PERSONAL|COMPANY)$", desc: "Target visibility: PERSONAL | COMPANY; SYSTEM is read-only" }
+  ],
+  risk: "high-risk-write",
+  preflight: (ctx) => {
+    buildBody54(ctx);
+  },
+  dryRun: (ctx) => evalDryRun(ctx, "PATCH", pathFor86(ctx), void 0, buildBody54(ctx)),
+  execute: async (ctx) => evalApi(ctx, "PATCH", pathFor86(ctx), void 0, buildBody54(ctx))
+};
+
+// src/commands/evaluation/change-model-config-access-scope.ts
+function pathFor87(ctx) {
+  return `/model-configs/${evalPathId(ctx, "id")}/access-scope`;
+}
+function buildBody55(ctx) {
+  const accessScope = ctx.str("access-scope");
+  if (!["PERSONAL", "COMPANY"].includes(accessScope)) {
+    throw new CliValidationError("--access-scope must be PERSONAL or COMPANY");
+  }
+  return { access_scope: accessScope, lock_version: ctx.num("lock-version") };
+}
+var changeModelConfigAccessScope = {
+  service: "evaluation",
+  resource: "model-config",
+  command: "access-scope",
+  description: "Change model-config visibility within the current project. Requires an administrator and the current lock_version. COMPANY assets cannot depend on private configurations or credentials.",
+  flags: [
+    ...evalFlags(),
+    ...idAndLockFlags("Model config UUID", "model-config"),
+    { name: "access-scope", type: "string", required: true, pattern: "^(PERSONAL|COMPANY)$", desc: "Target visibility: PERSONAL | COMPANY; SYSTEM is read-only" }
+  ],
+  risk: "high-risk-write",
+  preflight: (ctx) => {
+    buildBody55(ctx);
+  },
+  dryRun: (ctx) => evalDryRun(ctx, "PATCH", pathFor87(ctx), void 0, buildBody55(ctx)),
+  execute: async (ctx) => evalApi(ctx, "PATCH", pathFor87(ctx), void 0, buildBody55(ctx))
+};
+
+// src/commands/evaluation/change-agent-access-scope.ts
+function pathFor88(ctx) {
+  return `/agents/${evalPathId(ctx, "id")}/access-scope`;
+}
+function buildBody56(ctx) {
+  const accessScope = ctx.str("access-scope");
+  if (!["PERSONAL", "COMPANY"].includes(accessScope)) {
+    throw new CliValidationError("--access-scope must be PERSONAL or COMPANY");
+  }
+  return { access_scope: accessScope, lock_version: ctx.num("lock-version") };
+}
+var changeAgentAccessScope = {
+  service: "evaluation",
+  resource: "agent",
+  command: "access-scope",
+  description: "Change agent visibility within the current project. Requires an administrator and the current lock_version. COMPANY assets cannot depend on private configurations or credentials.",
+  flags: [
+    ...evalFlags(),
+    ...idAndLockFlags("Agent UUID", "agent"),
+    { name: "access-scope", type: "string", required: true, pattern: "^(PERSONAL|COMPANY)$", desc: "Target visibility: PERSONAL | COMPANY; SYSTEM is read-only" }
+  ],
+  risk: "high-risk-write",
+  preflight: (ctx) => {
+    buildBody56(ctx);
+  },
+  dryRun: (ctx) => evalDryRun(ctx, "PATCH", pathFor88(ctx), void 0, buildBody56(ctx)),
+  execute: async (ctx) => evalApi(ctx, "PATCH", pathFor88(ctx), void 0, buildBody56(ctx))
+};
+
+// src/commands/evaluation/enable-evaluator-template.ts
+function pathFor89(ctx) {
+  return `/evaluator-templates/${evalPathId(ctx, "id")}/enable`;
+}
+var enableEvaluatorTemplate = {
+  service: "evaluation",
+  resource: "evaluator-template",
+  command: "enable",
+  description: "Re-enable a project evaluator template. Administrator only; built-in templates cannot be enabled here. Repeated requests succeed without a request body.",
+  flags: [
+    ...evalFlags(),
+    idFlag("Project evaluator template UUID")
+  ],
+  risk: "write",
+  dryRun: (ctx) => evalDryRun(ctx, "POST", pathFor89(ctx)),
+  execute: async (ctx) => evalApi(ctx, "POST", pathFor89(ctx))
+};
+
+// src/commands/evaluation/list-project-member-candidates.ts
+var PATH111 = "/projects/members/candidates";
+var listProjectMemberCandidates = {
+  service: "evaluation",
+  resource: "project-member",
+  command: "list-candidates",
+  description: "List available TE company members for project admission. Administrator only; returns external_id, login_name and display_name, excluding frozen accounts and existing members.",
+  flags: [...evalFlags()],
+  risk: "read",
+  dryRun: (ctx) => evalDryRun(ctx, "GET", PATH111),
+  execute: async (ctx) => evalApi(ctx, "GET", PATH111)
+};
+
+// src/commands/evaluation/batch-add-project-members.ts
+var PATH112 = "/projects/members/batch-add";
+function buildBody57(ctx) {
+  const members = ctx.json("members-json");
+  if (!Array.isArray(members) || members.length === 0 || members.some((m) => !m || typeof m !== "object" || Array.isArray(m) || typeof m.external_id !== "string" || !m.external_id.trim() || m.external_id.length > 191 || m.display_name !== void 0 && (typeof m.display_name !== "string" || m.display_name.length > 128) || Object.keys(m).some((key) => !["external_id", "display_name"].includes(key)))) {
+    throw new CliValidationError("--members-json must be a nonempty array of {external_id, display_name?}");
+  }
+  return { members };
+}
+var batchAddProjectMembers = {
+  service: "evaluation",
+  resource: "project-member",
+  command: "batch-add",
+  description: "Admit TE identities to the current project whitelist. Administrator only; existing members are skipped. Use external IDs from project-member list-candidates.",
+  flags: [
+    ...evalFlags(),
+    { name: "members-json", type: "json", required: true, sensitive: true, desc: "Nonempty array of {external_id, display_name?}; external_id is a TE identity, not a member UUID" }
+  ],
+  risk: "high-risk-write",
+  preflight: (ctx) => {
+    buildBody57(ctx);
+  },
+  dryRun: (ctx) => evalDryRun(ctx, "POST", PATH112, void 0, buildBody57(ctx)),
+  execute: async (ctx) => evalApi(ctx, "POST", PATH112, void 0, buildBody57(ctx))
+};
+
+// src/commands/evaluation/change-project-member-role.ts
+function pathFor90(ctx) {
+  return `/projects/members/${evalPathId(ctx, "id")}/role`;
+}
+function buildBody58(ctx) {
+  const value = ctx.str("role");
+  if (!["agent_admin", "member"].includes(value)) {
+    throw new CliValidationError("--role must be agent_admin or member");
+  }
+  return { role: value };
+}
+var changeProjectMemberRole = {
+  service: "evaluation",
+  resource: "project-member",
+  command: "change-role",
+  description: "Change a project role. Administrator only; root members are protected.",
+  flags: [
+    ...evalFlags(),
+    idFlag("Project member user UUID from +list_project_members"),
+    { name: "role", type: "string", required: true, pattern: "^(agent_admin|member)$", desc: "Target role: agent_admin | member" }
+  ],
+  risk: "high-risk-write",
+  preflight: (ctx) => {
+    buildBody58(ctx);
+  },
+  dryRun: (ctx) => evalDryRun(ctx, "PATCH", pathFor90(ctx), void 0, buildBody58(ctx)),
+  execute: async (ctx) => evalApi(ctx, "PATCH", pathFor90(ctx), void 0, buildBody58(ctx))
+};
+
+// src/commands/evaluation/set-project-member-status.ts
+function pathFor91(ctx) {
+  return `/projects/members/${evalPathId(ctx, "id")}`;
+}
+function buildBody59(ctx) {
+  const value = ctx.str("status");
+  if (!["ACTIVE", "DISABLED"].includes(value)) {
+    throw new CliValidationError("--status must be ACTIVE or DISABLED");
+  }
+  return { status: value };
+}
+var setProjectMemberStatus = {
+  service: "evaluation",
+  resource: "project-member",
+  command: "set-status",
+  description: "Enable or disable a login across every project in the tenant. Administrator only; identities with a root role are protected.",
+  flags: [
+    ...evalFlags(),
+    idFlag("Project member user UUID from +list_project_members"),
+    { name: "status", type: "string", required: true, pattern: "^(ACTIVE|DISABLED)$", desc: "Target status: ACTIVE | DISABLED" }
+  ],
+  risk: "high-risk-write",
+  preflight: (ctx) => {
+    buildBody59(ctx);
+  },
+  dryRun: (ctx) => evalDryRun(ctx, "PATCH", pathFor91(ctx), void 0, buildBody59(ctx)),
+  execute: async (ctx) => evalApi(ctx, "PATCH", pathFor91(ctx), void 0, buildBody59(ctx))
+};
+
+// src/commands/evaluation/remove-project-member.ts
+function pathFor92(ctx) {
+  return `/projects/members/${evalPathId(ctx, "id")}`;
+}
+var removeProjectMember = {
+  service: "evaluation",
+  resource: "project-member",
+  command: "remove",
+  description: "Revoke membership and future login access to the current project until explicitly re-added. Administrator only; root members are protected. Other projects are unaffected.",
+  flags: [
+    ...evalFlags(),
+    idFlag("Project member user UUID from +list_project_members")
+  ],
+  risk: "high-risk-write",
+  dryRun: (ctx) => evalDryRun(ctx, "DELETE", pathFor92(ctx)),
+  execute: async (ctx) => evalApi(ctx, "DELETE", pathFor92(ctx))
+};
+
+// src/commands/evaluation/download-file.ts
+import { resolve as resolve2 } from "path";
+function pathFor93(ctx) {
+  return `/files/${evalPathId(ctx, "id")}/content`;
+}
+var downloadFile = {
+  service: "evaluation",
+  resource: "file",
+  command: "download",
+  description: "Download a completed, unexpired file through the authenticated API for local or S3 storage. Saves bytes to a new file; returns path and byte_size. Existing files are never overwritten.",
+  flags: [
+    ...evalFlags(),
+    idFlag("File UUID from an import or export operation"),
+    { name: "output", type: "string", required: true, minLength: 1, desc: "Destination file path; parent directory must exist and the file must not exist" }
+  ],
+  risk: "read",
+  dryRun: (ctx) => ({ ...evalDryRun(ctx, "GET", pathFor93(ctx)), output: resolve2(ctx.str("output")) }),
+  execute: async (ctx) => evalDownload(ctx, pathFor93(ctx), ctx.str("output"))
+};
+
+// src/commands/evaluation/index.ts
+var commands = [
+  changeDatasetAccessScope,
+  changeEvaluatorAccessScope,
+  changeModelConfigAccessScope,
+  changeAgentAccessScope,
+  enableEvaluatorTemplate,
+  listProjectMemberCandidates,
+  batchAddProjectMembers,
+  changeProjectMemberRole,
+  setProjectMemberStatus,
+  removeProjectMember,
+  downloadFile,
+  listDatasets,
+  getDataset,
+  createDataset,
+  importDataset,
+  datasetImportStatus,
+  datasetImportErrors,
+  updateDataset,
+  deleteDataset,
+  transferDatasetOwner,
+  listDatasetFields,
+  createDatasetField,
+  batchCreateDatasetFields,
+  updateDatasetField,
+  deleteDatasetField,
+  reorderDatasetFields,
+  listDatasetCases,
+  getDatasetCase,
+  createDatasetCase,
+  batchCreateDatasetCases,
+  updateDatasetCase,
+  deleteDatasetCase,
+  exportDataset,
+  listDatasetVersions,
+  publishDatasetVersion,
+  getDatasetVersion,
+  listDatasetReferences,
+  listEvaluators,
+  getEvaluator,
+  createEvaluator,
+  updateEvaluator,
+  deleteEvaluator,
+  transferEvaluatorOwner,
+  listEvaluatorTemplates,
+  createEvaluatorTemplate,
+  disableEvaluatorTemplate,
+  listEvaluatorVersions,
+  publishEvaluatorVersion,
+  optimizeEvaluatorPrompt,
+  getEvaluatorHealth,
+  listCalibrationSuites,
+  createCalibrationSuite,
+  listCalibrationCases,
+  createCalibrationCase,
+  deleteCalibrationCase,
+  startCalibrationRun,
+  getCalibrationRun,
+  listCalibrationResults,
+  listRuns,
+  getRun,
+  createRun,
+  updateRun,
+  deleteRun,
+  selectRunEvaluators,
+  listRunEvaluators,
+  updateRunFieldMapping,
+  updateRunResultFilterFields,
+  validateRun,
+  startRun,
+  cancelRun,
+  runOverview,
+  runCases,
+  getRunCase,
+  exportRunResults,
+  exportRunLowScores,
+  fileDownloadUrl,
+  getFile,
+  createNextTaskVersionDraft,
+  listEvaluationTaskVersions,
+  retryFailedRunCases,
+  getRunCaseTrace,
+  retryRunCaseTrace,
+  runDistribution,
+  copyRunCase,
+  transferRunOwner,
+  listSchedules,
+  createSchedule,
+  updateSchedule,
+  deleteSchedule,
+  getTeReportConfig,
+  saveTeReportConfig,
+  getAiMonitorConnection,
+  saveAiMonitorConnection,
+  verifyAiMonitorConnection,
+  importAiMonitorTraces,
+  listTeClaudeCatalog,
+  listProjectMembers,
+  listModelConfigs,
+  getModelConfig,
+  createModelConfig,
+  updateModelConfig,
+  deleteModelConfig,
+  testModelConfigConnectivity,
+  transferModelConfigOwner,
+  listAgents,
+  getAgent,
+  createAgent,
+  updateAgent,
+  deleteAgent,
+  testAgentConnectivity,
+  agentSnapshotPreview,
+  transferAgentOwner,
+  listCredentials,
+  getCredential,
+  createCredential,
+  updateCredential,
+  rotateCredential,
+  disableCredential,
+  enableCredential,
+  deleteCredential,
+  transferCredentialOwner
+];
+var evaluation_default = commands;
+export {
+  agentSnapshotPreview,
+  batchAddProjectMembers,
+  batchCreateDatasetCases,
+  batchCreateDatasetFields,
+  cancelRun,
+  changeAgentAccessScope,
+  changeDatasetAccessScope,
+  changeEvaluatorAccessScope,
+  changeModelConfigAccessScope,
+  changeProjectMemberRole,
+  copyRunCase,
+  createAgent,
+  createCalibrationCase,
+  createCalibrationSuite,
+  createCredential,
+  createDataset,
+  createDatasetCase,
+  createDatasetField,
+  createEvaluator,
+  createEvaluatorTemplate,
+  createModelConfig,
+  createNextTaskVersionDraft,
+  createRun,
+  createSchedule,
+  datasetImportErrors,
+  datasetImportStatus,
+  evaluation_default as default,
+  deleteAgent,
+  deleteCalibrationCase,
+  deleteCredential,
+  deleteDataset,
+  deleteDatasetCase,
+  deleteDatasetField,
+  deleteEvaluator,
+  deleteModelConfig,
+  deleteRun,
+  deleteSchedule,
+  disableCredential,
+  disableEvaluatorTemplate,
+  downloadFile,
+  enableCredential,
+  enableEvaluatorTemplate,
+  exportDataset,
+  exportRunLowScores,
+  exportRunResults,
+  fileDownloadUrl,
+  getAgent,
+  getAiMonitorConnection,
+  getCalibrationRun,
+  getCredential,
+  getDataset,
+  getDatasetCase,
+  getDatasetVersion,
+  getEvaluator,
+  getEvaluatorHealth,
+  getFile,
+  getModelConfig,
+  getRun,
+  getRunCase,
+  getRunCaseTrace,
+  getTeReportConfig,
+  importAiMonitorTraces,
+  importDataset,
+  listAgents,
+  listCalibrationCases,
+  listCalibrationResults,
+  listCalibrationSuites,
+  listCredentials,
+  listDatasetCases,
+  listDatasetFields,
+  listDatasetReferences,
+  listDatasetVersions,
+  listDatasets,
+  listEvaluationTaskVersions,
+  listEvaluatorTemplates,
+  listEvaluatorVersions,
+  listEvaluators,
+  listModelConfigs,
+  listProjectMemberCandidates,
+  listProjectMembers,
+  listRunEvaluators,
+  listRuns,
+  listSchedules,
+  listTeClaudeCatalog,
+  optimizeEvaluatorPrompt,
+  publishDatasetVersion,
+  publishEvaluatorVersion,
+  removeProjectMember,
+  reorderDatasetFields,
+  retryFailedRunCases,
+  retryRunCaseTrace,
+  rotateCredential,
+  runCases,
+  runDistribution,
+  runOverview,
+  saveAiMonitorConnection,
+  saveTeReportConfig,
+  selectRunEvaluators,
+  setProjectMemberStatus,
+  startCalibrationRun,
+  startRun,
+  testAgentConnectivity,
+  testModelConfigConnectivity,
+  transferAgentOwner,
+  transferCredentialOwner,
+  transferDatasetOwner,
+  transferEvaluatorOwner,
+  transferModelConfigOwner,
+  transferRunOwner,
+  updateAgent,
+  updateCredential,
+  updateDataset,
+  updateDatasetCase,
+  updateDatasetField,
+  updateEvaluator,
+  updateModelConfig,
+  updateRun,
+  updateRunFieldMapping,
+  updateRunResultFilterFields,
+  updateSchedule,
+  validateRun,
+  verifyAiMonitorConnection
+};