@thinkingai/ae-cli 6.0.30 → 6.0.31

package/dist/te-analysis-YGV5V5EX.js

@@ -0,0 +1,4530 @@
+import {
+  createCapabilityCommand
+} from "./chunk-N2QORU5D.js";
+import {
+  registerCapabilityGatewayRoute,
+  resolveGatewayDomain
+} from "./chunk-HL2AJQ4Q.js";
+import {
+  CapabilityGatewayError,
+  buildCapabilityGatewayUrl,
+  fetchCapabilityGateway,
+  requestCapabilityGateway,
+  requestCapabilityGatewayWithEnvelope,
+  uploadInputFile
+} from "./chunk-DYOS6YY7.js";
+import {
+  withOutputMetadata
+} from "./chunk-TNW2CI4W.js";
+import {
+  callMcpTool,
+  parseMcpResult,
+  resolveMcpUrl
+} from "./chunk-6LEYLOV3.js";
+import {
+  isGlobalQueryModeEnabled
+} from "./chunk-KGJQCYVC.js";
+import "./chunk-NOO24N7W.js";
+import "./chunk-2NDGFQHW.js";
+import "./chunk-AJTH7LT3.js";
+import "./chunk-YCLVYFK7.js";
+
+// src/commands/te-analysis/shared.ts
+function createMcpCommand(config) {
+  const toolName = config.command.slice(1);
+  const mcpService = config.mcpService || "analysis";
+  return {
+    service: "analysis",
+    command: config.command,
+    description: config.description,
+    flags: config.flags,
+    risk: config.risk,
+    validate: config.validate,
+    dryRun: (ctx) => ({
+      method: "tools/call",
+      url: resolveMcpUrl(ctx.mcpUrl(), ctx.host(), mcpService),
+      body: {
+        name: toolName,
+        arguments: config.buildArgs(ctx)
+      }
+    }),
+    execute: async (ctx) => {
+      const url = resolveMcpUrl(ctx.mcpUrl(), ctx.host(), mcpService);
+      const result = await callMcpTool(url, toolName, config.buildArgs(ctx), ctx.host());
+      return parseMcpResult(result);
+    }
+  };
+}
+function optionalString(ctx, name) {
+  const value = ctx.str(name);
+  return value === "" ? void 0 : value;
+}
+function optionalNumber(ctx, name) {
+  const value = ctx.str(name);
+  return value === "" ? void 0 : Number(value);
+}
+function optionalBoolean(ctx, name) {
+  const value = ctx.str(name);
+  return value === "" ? void 0 : ctx.bool(name);
+}
+function requiredJsonString(ctx, name) {
+  return JSON.stringify(ctx.json(name));
+}
+
+// src/commands/te-analysis/meta/get-alert-definition-schema.ts
+var getAlertDefinitionSchema = createMcpCommand({
+  command: "+get_alert_definition_schema",
+  description: "Get the alert definition schema. Returns field definitions, enum descriptions, and examples for creating or updating alerts.",
+  flags: [],
+  risk: "read",
+  mcpService: "te_analysis_extend",
+  buildArgs: () => ({})
+});
+
+// src/commands/te-analysis/meta/list-alerts.ts
+var listAlerts = createMcpCommand({
+  command: "+list_alerts",
+  description: "List all alerts in the project. Supports keyword filtering by alert name and returns a paginated alert list with total count.",
+  flags: [
+    { name: "project_id", type: "number", required: true, alias: "p", desc: "Project ID" },
+    { name: "query", type: "string", required: false, alias: "q", desc: "Optional keyword filter. Performs fuzzy matching against alert names; if omitted, all alerts are returned." },
+    { name: "limit", type: "number", required: false, alias: "l", desc: "Optional page size. Default: 50, maximum: 200.", min: 1, max: 200 },
+    { name: "offset", type: "number", required: false, alias: "o", desc: "Optional page offset. Default: 0." }
+  ],
+  risk: "read",
+  mcpService: "te_analysis_extend",
+  buildArgs: (ctx) => ({
+    projectId: ctx.num("project_id"),
+    query: optionalString(ctx, "query"),
+    limit: optionalNumber(ctx, "limit"),
+    offset: optionalNumber(ctx, "offset")
+  })
+});
+
+// src/commands/te-analysis/meta/get-alert.ts
+var getAlert = createMcpCommand({
+  command: "+get_alert",
+  description: "Get detailed information about a specific alert by alertId.",
+  flags: [
+    { name: "project_id", type: "number", required: true, alias: "p", desc: "Project ID" },
+    { name: "alert_id", type: "number", required: true, alias: "a", desc: "Alert ID" }
+  ],
+  risk: "read",
+  mcpService: "te_analysis_extend",
+  buildArgs: (ctx) => ({
+    projectId: ctx.num("project_id"),
+    alertId: ctx.num("alert_id")
+  })
+});
+
+// src/commands/te-analysis/meta/create-alert.ts
+var createAlert = createMcpCommand({
+  command: "+create_alert",
+  description: "Create a new alert. After creation, use list_alerts or get_alert to retrieve the created alert.",
+  flags: [
+    { name: "project_id", type: "number", required: true, alias: "p", desc: "Project ID" },
+    { name: "definition", type: "json", required: true, desc: "Alert definition JSON. See +get_alert_definition_schema for the complete structure." }
+  ],
+  risk: "write",
+  mcpService: "te_analysis_extend",
+  buildArgs: (ctx) => ({
+    projectId: ctx.num("project_id"),
+    definition: requiredJsonString(ctx, "definition")
+  })
+});
+
+// src/commands/te-analysis/meta/update-alert.ts
+var updateAlert = createMcpCommand({
+  command: "+update_alert",
+  description: "Update an existing alert. All fields in the definition will replace existing values.",
+  flags: [
+    { name: "project_id", type: "number", required: true, alias: "p", desc: "Project ID" },
+    { name: "alert_id", type: "number", required: true, alias: "a", desc: "Alert ID" },
+    { name: "definition", type: "json", required: true, desc: "Alert definition JSON with updated fields. See +get_alert_definition_schema for the complete structure." }
+  ],
+  risk: "write",
+  mcpService: "te_analysis_extend",
+  buildArgs: (ctx) => ({
+    projectId: ctx.num("project_id"),
+    alertId: ctx.num("alert_id"),
+    definition: requiredJsonString(ctx, "definition")
+  })
+});
+
+// src/commands/te-analysis/meta/delete-alert.ts
+var deleteAlert = createMcpCommand({
+  command: "+delete_alert",
+  description: "Delete an alert by alertId",
+  flags: [
+    { name: "project_id", type: "number", required: true, desc: "Project ID", alias: "p" },
+    { name: "alert_id", type: "number", required: true, desc: "Alert ID to delete" }
+  ],
+  risk: "high-risk-write",
+  mcpService: "te_analysis_extend",
+  buildArgs: (ctx) => ({
+    projectId: ctx.num("project_id"),
+    alertId: ctx.num("alert_id")
+  })
+});
+
+// src/commands/te-analysis/capability-shared.ts
+var analysisDataRunRoutingHelp = "Routing: use run only for analysis data that fits <=1000 inline rows and <=180s; use export for full, unknown-size, >1000-row, or long-running data.";
+var analysisDataExportRoutingHelp = "Routing: use export for full, unknown-size, >1000-row, or long-running analysis data; inspect/download by run_id/artifact_id; use run only for <=1000-row inline previews.";
+function createAnalysisCapabilityCommand(config) {
+  return createCapabilityCommand({
+    ...config,
+    cliService: "analysis"
+  });
+}
+function createAnalysisMetaCapabilityCommand(config) {
+  return createCapabilityCommand({
+    ...config,
+    cliService: "analysis-meta",
+    gatewayDomain: "analysis"
+  });
+}
+function createAnalysisGovernanceCapabilityCommand(config) {
+  return createCapabilityCommand({
+    ...config,
+    cliService: "analysis-governance",
+    gatewayDomain: "analysis"
+  });
+}
+var projectIdFlag = {
+  name: "project-id",
+  type: "number",
+  required: true,
+  desc: "Numeric project ID.",
+  alias: "p"
+};
+var queryFlag = {
+  name: "query",
+  type: "string",
+  required: false,
+  desc: "Optional keyword filter.",
+  alias: "q"
+};
+var fieldsFlag = {
+  name: "fields",
+  type: "json",
+  required: false,
+  desc: "Optional result field projection JSON array.",
+  alias: "f"
+};
+var limitFlag = {
+  name: "limit",
+  type: "number",
+  required: false,
+  desc: "Optional inline result limit.",
+  alias: "l"
+};
+var directoryLimitFlag = {
+  name: "limit",
+  type: "number",
+  required: false,
+  desc: "Directory page size. Default: 50, max: 200. Values outside 1..200 are rejected.",
+  alias: "l",
+  min: 1,
+  max: 200
+};
+var memberLimitFlag = {
+  name: "limit",
+  type: "number",
+  required: false,
+  desc: "Bounded member row limit. Default: 50, max: 200. Values outside 1..200 are rejected.",
+  alias: "l",
+  min: 1,
+  max: 200
+};
+var sqlTableUsageFlag = {
+  name: "usage",
+  type: "string",
+  required: false,
+  desc: "Authorized table set: analysis (default) or tag_cluster. Use tag_cluster before creating SQL tags or clusters."
+};
+var reportListLimitFlag = {
+  name: "limit",
+  type: "number",
+  required: false,
+  desc: "Report page size. Default: 50, max: 200. Values outside 1..200 are rejected.",
+  alias: "l",
+  min: 1,
+  max: 200
+};
+var reportModelTypesFlag = {
+  name: "model-types",
+  type: "json",
+  required: false,
+  desc: 'Optional semantic report model JSON array, for example ["event","sql","tag","revenue"].'
+};
+var syncLimitFlag = {
+  name: "limit",
+  type: "number",
+  required: false,
+  desc: "Maximum inline rows for sync query results. Default: 100, max: 1000. Use export for full data.",
+  alias: "l",
+  min: 1,
+  max: 1e3
+};
+var detailPreviewLimitFlag = {
+  name: "limit",
+  type: "number",
+  required: false,
+  desc: "Maximum first preview rows. Default: 100, max: 1000. This is not a pagination window; use export for more rows.",
+  alias: "l",
+  min: 1,
+  max: 1e3
+};
+var offsetFlag = {
+  name: "offset",
+  type: "number",
+  required: false,
+  desc: "Optional zero-based result offset.",
+  alias: "o"
+};
+var payloadFlag = {
+  name: "payload",
+  type: "json",
+  required: false,
+  desc: "Optional snake_case object for complex capability payload fields."
+};
+var requiredPayloadFlag = {
+  ...payloadFlag,
+  required: true,
+  desc: "Required snake_case capability payload. Read the dedicated command reference for its semantic shape; an empty object is not a generic valid payload."
+};
+var requestIdFlag = {
+  name: "request-id",
+  type: "string",
+  required: false,
+  desc: "Optional caller-supplied cli_<32 lowercase hex> lifecycle ID. ae-cli generates and prints one before dispatch when omitted."
+};
+var timeoutSecondsFlag = {
+  name: "timeout-seconds",
+  type: "number",
+  required: false,
+  desc: "Optional capability execution timeout in seconds."
+};
+var syncTimeoutSecondsFlag = {
+  name: "timeout-seconds",
+  type: "number",
+  required: false,
+  desc: "Sync timeout seconds. Default: 120, max: 180.",
+  min: 1,
+  max: 180
+};
+var dashboardSyncTimeoutSecondsFlag = {
+  ...syncTimeoutSecondsFlag,
+  desc: "Sync timeout seconds. Default: 180, max: 180."
+};
+var asyncTimeoutSecondsFlag = {
+  name: "timeout-seconds",
+  type: "number",
+  required: false,
+  desc: "Async runtime in seconds. Default and max: 21600 (6 hours); cancel earlier with analysis query cancel --run-id <run_id>.",
+  min: 1,
+  max: 21600
+};
+var artifactFormatFlag = {
+  name: "artifact-format",
+  type: "string",
+  required: false,
+  desc: "Logical artifact format, usually jsonl or csv. This does not select compression; read format, compression, file_name, content_type, and content_encoding from the returned descriptor."
+};
+function projectInput(ctx) {
+  return { project_id: ctx.num("project-id") };
+}
+function listInput(ctx) {
+  return compactInput({
+    ...projectInput(ctx),
+    query: optionalString2(ctx, "query"),
+    fields: optionalJson(ctx, "fields"),
+    limit: optionalNumber2(ctx, "limit"),
+    offset: optionalNumber2(ctx, "offset")
+  });
+}
+function reportListInput(ctx) {
+  return compactInput({
+    ...listInput(ctx),
+    model_types: optionalJson(ctx, "model-types")
+  });
+}
+function dashboardReportDataInput(ctx) {
+  return compactInput({
+    ...projectInput(ctx),
+    dashboard_id: ctx.num("dashboard-id"),
+    report_ids: optionalJsonArray(ctx, "report-ids"),
+    filters: optionalJson(ctx, "filters"),
+    start_time: optionalString2(ctx, "start-time"),
+    end_time: optionalString2(ctx, "end-time"),
+    use_cache: optionalBoolean2(ctx, "use-cache"),
+    request_id: optionalString2(ctx, "request-id"),
+    timeout_seconds: optionalNumber2(ctx, "timeout-seconds"),
+    limit: optionalNumber2(ctx, "limit"),
+    format: optionalString2(ctx, "artifact-format")
+  });
+}
+function exportLifecycleInput(ctx) {
+  return compactInput({
+    request_id: optionalString2(ctx, "request-id"),
+    timeout_seconds: optionalNumber2(ctx, "timeout-seconds"),
+    format: optionalString2(ctx, "artifact-format")
+  });
+}
+function biPanelPageDataInput(ctx) {
+  return compactInput({
+    ...projectInput(ctx),
+    panel_id: ctx.num("panel-id"),
+    page_key: ctx.str("page-key"),
+    result_type: ctx.str("result-type"),
+    chart_ids: optionalJsonArray(ctx, "chart-ids"),
+    parameter_controls: optionalJson(ctx, "parameter-controls"),
+    permission_controls: optionalJson(ctx, "permission-controls"),
+    chart_filter_controls: optionalJson(ctx, "chart-filter-controls"),
+    columns: optionalJson(ctx, "columns"),
+    row_limit: optionalNumber2(ctx, "row-limit"),
+    row_offset: optionalNumber2(ctx, "row-offset"),
+    block_limit: optionalNumber2(ctx, "block-limit"),
+    block_offset: optionalNumber2(ctx, "block-offset"),
+    use_cache: optionalBoolean2(ctx, "use-cache"),
+    request_id: optionalString2(ctx, "request-id"),
+    timeout_seconds: optionalNumber2(ctx, "timeout-seconds"),
+    limit: optionalNumber2(ctx, "limit"),
+    format: optionalString2(ctx, "artifact-format")
+  });
+}
+function optionalString2(ctx, name) {
+  const value = ctx.str(name);
+  return value === "" ? void 0 : value;
+}
+function optionalNumber2(ctx, name) {
+  const value = ctx.str(name);
+  return value === "" ? void 0 : Number(value);
+}
+function optionalBoolean2(ctx, name) {
+  const value = ctx.str(name);
+  return value === "" ? void 0 : ctx.bool(name);
+}
+function stringWithDefault(ctx, name, defaultValue) {
+  const value = ctx.str(name);
+  return value === "" ? defaultValue : value;
+}
+function numberWithDefault(ctx, name, defaultValue) {
+  const value = ctx.str(name);
+  return value === "" ? defaultValue : Number(value);
+}
+function booleanWithDefault(ctx, name, defaultValue) {
+  const value = ctx.str(name);
+  return value === "" ? defaultValue : ctx.bool(name);
+}
+function optionalJson(ctx, name) {
+  const value = ctx.str(name);
+  return value === "" ? void 0 : ctx.json(name);
+}
+function jsonArray(ctx, name) {
+  const value = ctx.json(name);
+  return Array.isArray(value) ? value : [value];
+}
+function optionalJsonArray(ctx, name) {
+  const value = ctx.str(name);
+  if (value === "") {
+    return void 0;
+  }
+  const parsed = ctx.json(name);
+  return Array.isArray(parsed) ? parsed : [parsed];
+}
+function compactInput(input) {
+  const result = {};
+  for (const [key, value] of Object.entries(input)) {
+    if (value !== void 0) {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function applyAnalysisInlineLimit(result, input) {
+  const limit = typeof input.limit === "number" && Number.isInteger(input.limit) && input.limit > 0 ? input.limit : void 0;
+  if (!limit) {
+    return result;
+  }
+  const cloned = cloneJsonLike(result);
+  const summary = {
+    truncated: false,
+    containers: 0,
+    originalRows: 0,
+    returnedRows: 0
+  };
+  trimRows(cloned, limit, summary);
+  if (summary.truncated && cloned && typeof cloned === "object" && !Array.isArray(cloned)) {
+    cloned._cli_inline_limit = {
+      requested_limit: limit,
+      containers_truncated: summary.containers,
+      original_rows: summary.originalRows,
+      returned_rows: summary.returnedRows,
+      note: "Rows were truncated by ae-cli to keep sync run output within the inline limit. Use export for full data."
+    };
+  }
+  return cloned;
+}
+function cloneJsonLike(value) {
+  if (value === void 0 || value === null) return value;
+  return JSON.parse(JSON.stringify(value));
+}
+function trimRows(value, limit, summary) {
+  if (!value || typeof value !== "object") return;
+  if (Array.isArray(value)) {
+    for (const item of value) trimRows(item, limit, summary);
+    return;
+  }
+  const record = value;
+  const rows = record.rows;
+  if (Array.isArray(rows) && rows.length > limit) {
+    record.rows = rows.slice(0, limit);
+    record._cli_truncation = {
+      field: "rows",
+      requested_limit: limit,
+      original_row_count: rows.length,
+      returned_row_count: limit
+    };
+    summary.truncated = true;
+    summary.containers += 1;
+    summary.originalRows += rows.length;
+    summary.returnedRows += limit;
+  }
+  for (const child of Object.values(record)) {
+    trimRows(child, limit, summary);
+  }
+}
+
+// src/commands/te-analysis/meta/event/list.ts
+var metadataEventList = createAnalysisMetaCapabilityCommand({
+  resource: "event",
+  command: "list",
+  capabilityId: "metadata.event.list",
+  description: "List project super events.",
+  flags: [
+    projectIdFlag
+  ],
+  risk: "read",
+  buildInput: projectInput
+});
+
+// src/commands/te-analysis/meta/event/get.ts
+var metadataEventGet = createAnalysisMetaCapabilityCommand({
+  resource: "event",
+  command: "get",
+  capabilityId: "metadata.event.get",
+  description: "Get one super event metadata detail.",
+  flags: [
+    projectIdFlag,
+    { name: "event-name", type: "string", required: true, desc: "Event name." }
+  ],
+  risk: "read",
+  buildInput: (ctx) => ({ ...projectInput(ctx), event_name: ctx.str("event-name") })
+});
+
+// src/commands/te-analysis/meta/event/create.ts
+var metadataEventCreate = createAnalysisMetaCapabilityCommand({
+  resource: "event",
+  command: "create",
+  capabilityId: "metadata.event.create",
+  description: "Create super events and optionally associate event properties.",
+  flags: [
+    projectIdFlag,
+    requiredPayloadFlag
+  ],
+  risk: "write",
+  buildInput: (ctx) => ({ ...projectInput(ctx), payload: ctx.json("payload") })
+});
+
+// src/commands/te-analysis/meta/event/update.ts
+var metadataEventUpdate = createAnalysisMetaCapabilityCommand({
+  resource: "event",
+  command: "update",
+  capabilityId: "metadata.event.update",
+  description: "Update event display names and remarks.",
+  flags: [
+    projectIdFlag,
+    { name: "event-name", type: "string", required: true, desc: "Event name." },
+    { name: "event-desc", type: "string", required: false, desc: "Event display name." },
+    { name: "remark", type: "string", required: false, desc: "Event remark." }
+  ],
+  risk: "write",
+  buildInput: (ctx) => compactInput({ ...projectInput(ctx), event_name: ctx.str("event-name"), event_desc: optionalString2(ctx, "event-desc"), remark: optionalString2(ctx, "remark") })
+});
+
+// src/commands/te-analysis/meta/event/relation-update.ts
+var metadataEventRelationUpdate = createAnalysisMetaCapabilityCommand({
+  resource: "event",
+  command: "relation-update",
+  capabilityId: "metadata.event.relation_update",
+  description: "Update event-property connection or source relations.",
+  flags: [
+    projectIdFlag,
+    requiredPayloadFlag
+  ],
+  risk: "write",
+  buildInput: (ctx) => ({ ...projectInput(ctx), payload: ctx.json("payload") })
+});
+
+// src/commands/te-analysis/meta/event/hide-update.ts
+var metadataEventHideUpdate = createAnalysisMetaCapabilityCommand({
+  resource: "event",
+  command: "hide-update",
+  capabilityId: "metadata.event.hide_update",
+  description: "Batch hide or show events.",
+  flags: [
+    projectIdFlag,
+    { name: "event-names", type: "json", required: true, desc: "Event names JSON array, or a JSON string accepted by common-service." },
+    { name: "is-hide", type: "boolean", required: true, desc: "Whether to hide the events." }
+  ],
+  risk: "write",
+  buildInput: (ctx) => ({ ...projectInput(ctx), event_names: ctx.json("event-names"), is_hide: ctx.bool("is-hide") })
+});
+
+// src/commands/te-analysis/meta/event/delete.ts
+var metadataEventDelete = createAnalysisMetaCapabilityCommand({
+  resource: "event",
+  command: "delete",
+  capabilityId: "metadata.event.delete",
+  description: "Batch delete events or virtual events.",
+  flags: [
+    projectIdFlag,
+    { name: "event-names", type: "json", required: true, desc: "Event names JSON array, or a JSON string accepted by common-service." }
+  ],
+  risk: "high-risk-write",
+  buildInput: (ctx) => ({ ...projectInput(ctx), event_names: ctx.json("event-names") })
+});
+
+// src/commands/te-analysis/meta/event/influence-list.ts
+var metadataEventInfluenceList = createAnalysisMetaCapabilityCommand({
+  resource: "event",
+  command: "influence-list",
+  capabilityId: "metadata.event.influence_list",
+  description: "List assets affected by event delete, hide, or update.",
+  flags: [
+    projectIdFlag,
+    { name: "event-name", type: "string", required: true, desc: "Event name." }
+  ],
+  risk: "read",
+  buildInput: (ctx) => ({ ...projectInput(ctx), event_name: ctx.str("event-name") })
+});
+
+// src/commands/te-analysis/meta/event/changelog-list.ts
+var metadataEventChangelogList = createAnalysisMetaCapabilityCommand({
+  resource: "event",
+  command: "changelog-list",
+  capabilityId: "metadata.event.changelog_list",
+  description: "List event metadata change logs.",
+  flags: [
+    projectIdFlag,
+    { name: "event-name", type: "string", required: true, desc: "Event name." }
+  ],
+  risk: "read",
+  buildInput: (ctx) => ({ ...projectInput(ctx), event_name: ctx.str("event-name") })
+});
+
+// src/commands/te-analysis/meta/event/index.ts
+var commands = [
+  metadataEventList,
+  metadataEventGet,
+  metadataEventCreate,
+  metadataEventUpdate,
+  metadataEventRelationUpdate,
+  metadataEventHideUpdate,
+  metadataEventDelete,
+  metadataEventInfluenceList,
+  metadataEventChangelogList
+];
+var event_default = commands;
+
+// src/commands/te-analysis/meta/property/list.ts
+var metadataPropertyList = createAnalysisMetaCapabilityCommand({
+  resource: "property",
+  command: "list",
+  capabilityId: "metadata.property.list",
+  description: "List event or user properties.",
+  flags: [
+    projectIdFlag,
+    { name: "table-type", type: "string", required: true, desc: "Property table type." }
+  ],
+  risk: "read",
+  buildInput: (ctx) => ({ ...projectInput(ctx), table_type: ctx.str("table-type") })
+});
+
+// src/commands/te-analysis/meta/property/get.ts
+var metadataPropertyGet = createAnalysisMetaCapabilityCommand({
+  resource: "property",
+  command: "get",
+  capabilityId: "metadata.property.get",
+  description: "Get one event or user property metadata detail.",
+  flags: [
+    projectIdFlag,
+    { name: "table-type", type: "string", required: true, desc: "Property table type." },
+    { name: "prop-name", type: "string", required: true, desc: "Property column name." }
+  ],
+  risk: "read",
+  buildInput: (ctx) => ({ ...projectInput(ctx), table_type: ctx.str("table-type"), prop_name: ctx.str("prop-name") })
+});
+
+// src/commands/te-analysis/meta/property/create.ts
+var metadataPropertyCreate = createAnalysisMetaCapabilityCommand({
+  resource: "property",
+  command: "create",
+  capabilityId: "metadata.property.create",
+  description: "Create event or user properties and optionally associate events.",
+  flags: [
+    projectIdFlag,
+    { name: "table-type", type: "string", required: true, desc: "Property table type." },
+    requiredPayloadFlag
+  ],
+  risk: "write",
+  buildInput: (ctx) => ({ ...projectInput(ctx), table_type: ctx.str("table-type"), payload: ctx.json("payload") })
+});
+
+// src/commands/te-analysis/meta/property/update.ts
+var metadataPropertyUpdate = createAnalysisMetaCapabilityCommand({
+  resource: "property",
+  command: "update",
+  capabilityId: "metadata.property.update",
+  description: "Update property display names and remarks.",
+  flags: [
+    projectIdFlag,
+    { name: "table-type", type: "string", required: true, desc: "Property table type." },
+    { name: "prop-name", type: "string", required: true, desc: "Property column name." },
+    { name: "prop-desc", type: "string", required: false, desc: "Property display name." },
+    { name: "prop-remark", type: "string", required: false, desc: "Property remark." }
+  ],
+  risk: "write",
+  buildInput: (ctx) => compactInput({ ...projectInput(ctx), table_type: ctx.str("table-type"), prop_name: ctx.str("prop-name"), prop_desc: optionalString2(ctx, "prop-desc"), prop_remark: optionalString2(ctx, "prop-remark") })
+});
+
+// src/commands/te-analysis/meta/property/relation-update.ts
+var metadataPropertyRelationUpdate = createAnalysisMetaCapabilityCommand({
+  resource: "property",
+  command: "relation-update",
+  capabilityId: "metadata.property.relation_update",
+  description: "Update property type, connection relation, or event mapping.",
+  flags: [
+    projectIdFlag,
+    { name: "table-type", type: "string", required: true, desc: "Property table type." },
+    requiredPayloadFlag
+  ],
+  risk: "write",
+  buildInput: (ctx) => ({ ...projectInput(ctx), table_type: ctx.str("table-type"), payload: ctx.json("payload") })
+});
+
+// src/commands/te-analysis/meta/property/hide-update.ts
+var metadataPropertyHideUpdate = createAnalysisMetaCapabilityCommand({
+  resource: "property",
+  command: "hide-update",
+  capabilityId: "metadata.property.hide_update",
+  description: "Batch hide or show properties.",
+  flags: [
+    projectIdFlag,
+    { name: "table-type", type: "string", required: true, desc: "Property table type." },
+    { name: "prop-names", type: "json", required: true, desc: "Property names JSON array, or a JSON string accepted by common-service." },
+    { name: "is-hide", type: "boolean", required: true, desc: "Whether to hide the properties." }
+  ],
+  risk: "write",
+  buildInput: (ctx) => ({ ...projectInput(ctx), table_type: ctx.str("table-type"), prop_names: ctx.json("prop-names"), is_hide: ctx.bool("is-hide") })
+});
+
+// src/commands/te-analysis/meta/property/delete.ts
+var metadataPropertyDelete = createAnalysisMetaCapabilityCommand({
+  resource: "property",
+  command: "delete",
+  capabilityId: "metadata.property.delete",
+  description: "Batch delete properties or virtual properties.",
+  flags: [
+    projectIdFlag,
+    { name: "table-type", type: "string", required: true, desc: "Property table type." },
+    { name: "prop-names", type: "json", required: true, desc: "Property names JSON array, or a JSON string accepted by common-service." }
+  ],
+  risk: "high-risk-write",
+  buildInput: (ctx) => ({ ...projectInput(ctx), table_type: ctx.str("table-type"), prop_names: ctx.json("prop-names") })
+});
+
+// src/commands/te-analysis/meta/property/influence-list.ts
+var metadataPropertyInfluenceList = createAnalysisMetaCapabilityCommand({
+  resource: "property",
+  command: "influence-list",
+  capabilityId: "metadata.property.influence_list",
+  description: "List assets affected by property changes.",
+  flags: [
+    projectIdFlag,
+    { name: "table-type", type: "string", required: true, desc: "Property table type." },
+    { name: "prop-name", type: "string", required: true, desc: "Property column name." }
+  ],
+  risk: "read",
+  buildInput: (ctx) => ({ ...projectInput(ctx), table_type: ctx.str("table-type"), prop_name: ctx.str("prop-name") })
+});
+
+// src/commands/te-analysis/meta/property/changelog-list.ts
+var metadataPropertyChangelogList = createAnalysisMetaCapabilityCommand({
+  resource: "property",
+  command: "changelog-list",
+  capabilityId: "metadata.property.changelog_list",
+  description: "List property metadata change logs.",
+  flags: [
+    projectIdFlag,
+    { name: "table-type", type: "string", required: true, desc: "Property table type." },
+    { name: "prop-name", type: "string", required: true, desc: "Property column name." }
+  ],
+  risk: "read",
+  buildInput: (ctx) => ({ ...projectInput(ctx), table_type: ctx.str("table-type"), prop_name: ctx.str("prop-name") })
+});
+
+// src/commands/te-analysis/meta/property/related-events.ts
+var metadataPropertyRelatedEvents = createAnalysisMetaCapabilityCommand({
+  resource: "property",
+  command: "related-events",
+  capabilityId: "metadata.property.related_events",
+  description: "List events related to one event property.",
+  flags: [
+    projectIdFlag,
+    { name: "prop-name", type: "string", required: true, desc: "Event property column name." }
+  ],
+  risk: "read",
+  buildInput: (ctx) => ({ ...projectInput(ctx), prop_name: ctx.str("prop-name") })
+});
+
+// src/commands/te-analysis/meta/property/index.ts
+var commands2 = [
+  metadataPropertyList,
+  metadataPropertyGet,
+  metadataPropertyCreate,
+  metadataPropertyUpdate,
+  metadataPropertyRelationUpdate,
+  metadataPropertyHideUpdate,
+  metadataPropertyDelete,
+  metadataPropertyInfluenceList,
+  metadataPropertyChangelogList,
+  metadataPropertyRelatedEvents
+];
+var property_default = commands2;
+
+// src/commands/te-analysis/meta/virtual-event/create.ts
+var metadataVirtualEventCreate = createAnalysisMetaCapabilityCommand({
+  resource: "virtual-event",
+  command: "create",
+  capabilityId: "metadata.virtual_event.create",
+  description: "Create a virtual event from events and filters.",
+  flags: [
+    projectIdFlag,
+    requiredPayloadFlag,
+    { name: "override", type: "boolean", required: false, desc: "Whether to override an existing virtual event rule." }
+  ],
+  risk: "write",
+  buildInput: (ctx) => compactInput({ ...projectInput(ctx), payload: ctx.json("payload"), override: optionalBoolean2(ctx, "override") })
+});
+
+// src/commands/te-analysis/meta/virtual-event/get.ts
+var metadataVirtualEventGet = createAnalysisMetaCapabilityCommand({
+  resource: "virtual-event",
+  command: "get",
+  capabilityId: "metadata.virtual_event.get",
+  description: "Get virtual event rule.",
+  flags: [
+    projectIdFlag,
+    { name: "v-event-id", type: "number", required: true, desc: "Virtual event ID." }
+  ],
+  risk: "read",
+  buildInput: (ctx) => ({ ...projectInput(ctx), v_event_id: ctx.num("v-event-id") })
+});
+
+// src/commands/te-analysis/meta/virtual-event/delete.ts
+var metadataVirtualEventDelete = createAnalysisMetaCapabilityCommand({
+  resource: "virtual-event",
+  command: "delete",
+  capabilityId: "metadata.virtual_event.delete",
+  description: "Delete a virtual event rule.",
+  flags: [
+    projectIdFlag,
+    { name: "v-event-id", type: "number", required: true, desc: "Virtual event ID." }
+  ],
+  risk: "high-risk-write",
+  buildInput: (ctx) => ({ ...projectInput(ctx), v_event_id: ctx.num("v-event-id") })
+});
+
+// src/commands/te-analysis/meta/virtual-event/index.ts
+var commands3 = [
+  metadataVirtualEventCreate,
+  metadataVirtualEventGet,
+  metadataVirtualEventDelete
+];
+var virtual_event_default = commands3;
+
+// src/commands/te-analysis/meta/virtual-property/create.ts
+var metadataVirtualPropertyCreate = createAnalysisMetaCapabilityCommand({
+  resource: "virtual-property",
+  command: "create",
+  capabilityId: "metadata.virtual_property.create",
+  description: "Create a SQL virtual event or user property.",
+  flags: [
+    projectIdFlag,
+    { name: "sql-expression", type: "string", required: true, desc: "SQL expression used to calculate the virtual property." },
+    { name: "v-prop", type: "json", required: true, desc: "Virtual property JSON object with property.column_name/table_type/select_type fields." },
+    { name: "properties", type: "json", required: false, desc: "Dependent property JSON array." },
+    { name: "sql-event-relation-type", type: "string", required: false, desc: "relation_default, relation_always, or relation_by_setting." },
+    { name: "related-events", type: "json", required: false, desc: "Related events JSON array when using relation_by_setting." },
+    { name: "tag-date-policies", type: "json", required: false, desc: "Optional tag date policies JSON array." },
+    { name: "replace-remark", type: "string", required: false, desc: "Replacement remark." },
+    { name: "replace-suggestion", type: "string", required: false, desc: "Replacement suggestion." }
+  ],
+  risk: "write",
+  buildInput: (ctx) => compactInput({
+    ...projectInput(ctx),
+    sql_expression: ctx.str("sql-expression"),
+    v_prop: ctx.json("v-prop"),
+    properties: optionalJson(ctx, "properties"),
+    sql_event_relation_type: optionalString2(ctx, "sql-event-relation-type"),
+    related_events: optionalJson(ctx, "related-events"),
+    tag_date_policies: optionalJson(ctx, "tag-date-policies"),
+    replace_remark: optionalString2(ctx, "replace-remark"),
+    replace_suggestion: optionalString2(ctx, "replace-suggestion")
+  })
+});
+
+// src/commands/te-analysis/meta/virtual-property/sql-rule-update.ts
+var metadataVirtualPropertySqlRuleUpdate = createAnalysisMetaCapabilityCommand({
+  resource: "virtual-property",
+  command: "sql-rule-update",
+  capabilityId: "metadata.virtual_property.sql_rule_update",
+  description: "Update SQL virtual property rule.",
+  flags: [
+    projectIdFlag,
+    { name: "sql-expression", type: "string", required: true, desc: "SQL expression used to calculate the virtual property." },
+    { name: "v-prop", type: "json", required: true, desc: "Virtual property JSON object with prop_id/property fields." },
+    { name: "properties", type: "json", required: false, desc: "Dependent property JSON array." },
+    { name: "sql-event-relation-type", type: "string", required: false, desc: "relation_default, relation_always, or relation_by_setting." },
+    { name: "related-events", type: "json", required: false, desc: "Related events JSON array when using relation_by_setting." },
+    { name: "tag-date-policies", type: "json", required: false, desc: "Optional tag date policies JSON array." },
+    { name: "replace-remark", type: "string", required: false, desc: "Replacement remark." },
+    { name: "replace-suggestion", type: "string", required: false, desc: "Replacement suggestion." }
+  ],
+  risk: "write",
+  buildInput: (ctx) => compactInput({
+    ...projectInput(ctx),
+    sql_expression: ctx.str("sql-expression"),
+    v_prop: ctx.json("v-prop"),
+    properties: optionalJson(ctx, "properties"),
+    sql_event_relation_type: optionalString2(ctx, "sql-event-relation-type"),
+    related_events: optionalJson(ctx, "related-events"),
+    tag_date_policies: optionalJson(ctx, "tag-date-policies"),
+    replace_remark: optionalString2(ctx, "replace-remark"),
+    replace_suggestion: optionalString2(ctx, "replace-suggestion")
+  })
+});
+
+// src/commands/te-analysis/meta/virtual-property/sql-rule-delete.ts
+var metadataVirtualPropertySqlRuleDelete = createAnalysisMetaCapabilityCommand({
+  resource: "virtual-property",
+  command: "sql-rule-delete",
+  capabilityId: "metadata.virtual_property.sql_rule_delete",
+  description: "Delete or revoke SQL virtual property rule.",
+  flags: [
+    projectIdFlag,
+    { name: "v-prop-id", type: "number", required: true, desc: "Virtual property ID." },
+    { name: "operation", type: "string", required: false, desc: "Delete operation. Use revoke to revoke instead of delete." }
+  ],
+  risk: "high-risk-write",
+  buildInput: (ctx) => compactInput({ ...projectInput(ctx), v_prop_id: ctx.num("v-prop-id"), operation: optionalString2(ctx, "operation") })
+});
+
+// src/commands/te-analysis/meta/virtual-property/index.ts
+var commands4 = [
+  metadataVirtualPropertyCreate,
+  metadataVirtualPropertySqlRuleUpdate,
+  metadataVirtualPropertySqlRuleDelete
+];
+var virtual_property_default = commands4;
+
+// src/commands/te-analysis/meta/metric/list.ts
+var metadataMetricList = createAnalysisMetaCapabilityCommand({
+  resource: "metric",
+  command: "list",
+  capabilityId: "metadata.metric.list",
+  description: "List project metrics.",
+  flags: [
+    projectIdFlag,
+    { name: "ignore-authentication", type: "boolean", required: false, desc: "Whether to skip asset authentication status decoration." }
+  ],
+  risk: "read",
+  buildInput: (ctx) => compactInput({ ...projectInput(ctx), ignore_authentication: optionalBoolean2(ctx, "ignore-authentication") })
+});
+
+// src/commands/te-analysis/meta/metric/get.ts
+var metadataMetricGet = createAnalysisMetaCapabilityCommand({
+  resource: "metric",
+  command: "get",
+  capabilityId: "metadata.metric.get",
+  description: "Get metric definition, events, and params.",
+  flags: [
+    projectIdFlag,
+    { name: "metric-id", type: "number", required: true, desc: "Metric ID." }
+  ],
+  risk: "read",
+  buildInput: (ctx) => ({ ...projectInput(ctx), metric_id: ctx.num("metric-id") })
+});
+
+// src/commands/te-analysis/meta/metric/create.ts
+var metadataMetricCreate = createAnalysisMetaCapabilityCommand({
+  resource: "metric",
+  command: "create",
+  capabilityId: "metadata.metric.create",
+  description: "Create a metric from event or retention analysis configuration.",
+  flags: [
+    projectIdFlag,
+    { name: "metric-name", type: "string", required: true, desc: "Metric technical name, for example pay_count." },
+    { name: "metric-desc", type: "string", required: true, desc: "Metric display name." },
+    { name: "metric-remark", type: "string", required: false, desc: "Metric remark." },
+    { name: "metric-mode", type: "number", required: true, desc: "Metric model mode, for example 0 for event analysis." },
+    { name: "metric-events", type: "json", required: true, desc: "Metric event-analysis QP JSON array." },
+    { name: "metric-params", type: "json", required: false, desc: "Metric params JSON object. Defaults to {} in common when omitted." }
+  ],
+  risk: "write",
+  buildInput: (ctx) => compactInput({
+    ...projectInput(ctx),
+    metric_name: ctx.str("metric-name"),
+    metric_desc: ctx.str("metric-desc"),
+    metric_remark: optionalString2(ctx, "metric-remark"),
+    metric_mode: ctx.num("metric-mode"),
+    metric_events: ctx.json("metric-events"),
+    metric_params: optionalJson(ctx, "metric-params")
+  })
+});
+
+// src/commands/te-analysis/meta/metric/update.ts
+var metadataMetricUpdate = createAnalysisMetaCapabilityCommand({
+  resource: "metric",
+  command: "update",
+  capabilityId: "metadata.metric.update",
+  description: "Update metric definition, name, and remark.",
+  flags: [
+    projectIdFlag,
+    { name: "metric-id", type: "number", required: true, desc: "Metric ID." },
+    { name: "metric-name", type: "string", required: false, desc: "Metric technical name for full-definition update." },
+    { name: "metric-desc", type: "string", required: false, desc: "Metric display name." },
+    { name: "metric-remark", type: "string", required: false, desc: "Metric remark." },
+    { name: "metric-mode", type: "number", required: false, desc: "Metric model mode for full-definition update." },
+    { name: "metric-events", type: "json", required: false, desc: "Metric event-analysis QP JSON array for full-definition update." },
+    { name: "metric-params", type: "json", required: false, desc: "Metric params JSON object." }
+  ],
+  risk: "write",
+  buildInput: (ctx) => compactInput({
+    ...projectInput(ctx),
+    metric_id: ctx.num("metric-id"),
+    metric_name: optionalString2(ctx, "metric-name"),
+    metric_desc: optionalString2(ctx, "metric-desc"),
+    metric_remark: optionalString2(ctx, "metric-remark"),
+    metric_mode: optionalNumber2(ctx, "metric-mode"),
+    metric_events: optionalJson(ctx, "metric-events"),
+    metric_params: optionalJson(ctx, "metric-params")
+  })
+});
+
+// src/commands/te-analysis/meta/metric/delete.ts
+var metadataMetricDelete = createAnalysisMetaCapabilityCommand({
+  resource: "metric",
+  command: "delete",
+  capabilityId: "metadata.metric.delete",
+  description: "Delete a metric.",
+  flags: [
+    projectIdFlag,
+    { name: "metric-id", type: "number", required: true, desc: "Metric ID." }
+  ],
+  risk: "high-risk-write",
+  buildInput: (ctx) => ({ ...projectInput(ctx), metric_id: ctx.num("metric-id") })
+});
+
+// src/commands/te-analysis/meta/metric/index.ts
+var commands5 = [
+  metadataMetricList,
+  metadataMetricGet,
+  metadataMetricCreate,
+  metadataMetricUpdate,
+  metadataMetricDelete
+];
+var metric_default = commands5;
+
+// src/commands/te-analysis/meta/asset/search.ts
+var metadataAssetSearch = createAnalysisMetaCapabilityCommand({
+  resource: "asset",
+  command: "search",
+  capabilityId: "metadata.asset.search",
+  description: "Search project assets by keyword.",
+  flags: [
+    projectIdFlag,
+    requiredPayloadFlag
+  ],
+  risk: "read",
+  buildInput: (ctx) => ({ ...projectInput(ctx), payload: ctx.json("payload") })
+});
+
+// src/commands/te-analysis/meta/asset/recent-list.ts
+var metadataAssetRecentList = createAnalysisMetaCapabilityCommand({
+  resource: "asset",
+  command: "recent-list",
+  capabilityId: "metadata.asset.recent_list",
+  description: "List recently visited assets for the current user.",
+  flags: [
+    projectIdFlag,
+    requiredPayloadFlag
+  ],
+  risk: "read",
+  buildInput: (ctx) => ({ ...projectInput(ctx), payload: ctx.json("payload") })
+});
+
+// src/commands/te-analysis/meta/asset/authentication-list.ts
+var metadataAssetAuthenticationList = createAnalysisMetaCapabilityCommand({
+  resource: "asset-authentication",
+  command: "list",
+  capabilityId: "metadata.asset_authentication.list",
+  description: "List authenticatable project assets and authentication status.",
+  flags: [
+    projectIdFlag
+  ],
+  risk: "read",
+  buildInput: projectInput
+});
+
+// src/commands/te-analysis/meta/asset/authentication-update.ts
+var metadataAssetAuthenticationUpdate = createAnalysisMetaCapabilityCommand({
+  resource: "asset-authentication",
+  command: "update",
+  capabilityId: "metadata.asset_authentication.update",
+  description: "Batch authenticate or unauthenticate assets.",
+  flags: [
+    projectIdFlag,
+    requiredPayloadFlag
+  ],
+  risk: "write",
+  buildInput: (ctx) => ({ ...projectInput(ctx), payload: ctx.json("payload") })
+});
+
+// src/commands/te-analysis/meta/asset/abnormal-list.ts
+var metadataAssetAbnormalList = createAnalysisMetaCapabilityCommand({
+  resource: "asset-abnormal",
+  command: "list",
+  capabilityId: "metadata.asset_abnormal.list",
+  description: "List abnormal assets by resource type.",
+  flags: [
+    projectIdFlag,
+    { name: "resource-types", type: "string", required: true, desc: "Resource types to query." }
+  ],
+  risk: "read",
+  buildInput: (ctx) => ({ ...projectInput(ctx), resource_types: ctx.str("resource-types") })
+});
+
+// src/commands/te-analysis/meta/asset/abnormal-get.ts
+var metadataAssetAbnormalGet = createAnalysisMetaCapabilityCommand({
+  resource: "asset-abnormal",
+  command: "get",
+  capabilityId: "metadata.asset_abnormal.get",
+  description: "Get abnormal reason for one asset.",
+  flags: [
+    projectIdFlag,
+    { name: "resource-type", type: "string", required: true, desc: "Resource type." },
+    { name: "resource-id", type: "string", required: false, desc: "Resource ID." },
+    { name: "resource-name", type: "string", required: false, desc: "Resource name." },
+    { name: "table-type", type: "number", required: false, desc: "Property table type when the resource is a property." }
+  ],
+  risk: "read",
+  buildInput: (ctx) => compactInput({ ...projectInput(ctx), resource_type: ctx.str("resource-type"), resource_id: optionalString2(ctx, "resource-id"), resource_name: optionalString2(ctx, "resource-name"), table_type: optionalNumber2(ctx, "table-type") })
+});
+
+// src/commands/te-analysis/meta/asset/shared.ts
+var nodeIdFlag = { name: "node-id", type: "string", required: false, desc: "Poseidon asset node ID." };
+var resourceIdFlag = { name: "resource-id", type: "string", required: false, desc: "Asset business resource ID." };
+var resourceTypeFlag = { name: "resource-type", type: "string", required: false, desc: "Asset resource type." };
+var linkInfoFlag = { name: "link-info", type: "json", required: false, desc: "Asset link_info JSON." };
+var searchsFlag = { name: "searchs", type: "json", required: false, desc: "Quick filter JSON array." };
+var ruleFlag = { name: "rule", type: "json", required: false, desc: "Governance Filter JSON object." };
+var operationTypeFlag = { name: "operation-type", type: "string", required: false, desc: "Batch operation type." };
+var ruleIdFlag = { name: "rule-id", type: "number", required: false, desc: "Governance rule ID." };
+var ruleNameFlag = { name: "rule-name", type: "string", required: false, desc: "Governance rule name." };
+var commentFlag = { name: "comment", type: "string", required: false, desc: "Governance rule comment." };
+var nodeIdsFlag = { name: "node-ids", type: "json", required: false, desc: "Asset node ID JSON array." };
+var reportsVersionFlag = { name: "reports-version", type: "number", required: false, desc: "Dashboard reports version." };
+var zoneOffsetFlag = { name: "zone-offset", type: "number", required: false, desc: "Dashboard zone offset." };
+var scheduleUiConfigFlag = { name: "schedule-ui-config", type: "json", required: false, desc: "Dashboard schedule UI config JSON." };
+var dashboardStatusFlag = { name: "dashboard-status", type: "string", required: false, desc: "Dashboard status." };
+var refreshTypeFlag = { name: "refresh-type", type: "number", required: false, desc: "Dashboard refresh type: 1 enabled, 0 disabled." };
+var cacheConfigFlag = { name: "cache-config", type: "json", required: false, desc: "Dashboard cache config JSON." };
+var toUserIdFlag = { name: "to-user-id", type: "number", required: true, desc: "Target user ID for handover." };
+var clearHistoryTagFlag = { name: "clear-history-tag", type: "number", required: false, desc: "Whether to clear tag history: 1 yes, 0 no." };
+var typeFlag = { name: "type", type: "string", required: false, desc: "Batch operation type." };
+var statusFlag = { name: "status", type: "json", required: false, desc: "Operation status JSON array." };
+var sortFieldFlag = { name: "sort-field", type: "string", required: false, desc: "Sort field." };
+var sortOrderFlag = { name: "sort-order", type: "string", required: false, desc: "Sort order: asc or desc." };
+var recordIdFlag = { name: "record-id", type: "number", required: false, desc: "Operation record ID." };
+var readers = {
+  node_id: (ctx) => optionalString2(ctx, "node-id"),
+  resource_id: (ctx) => optionalString2(ctx, "resource-id"),
+  resource_type: (ctx) => optionalString2(ctx, "resource-type"),
+  link_info: (ctx) => optionalJson(ctx, "link-info"),
+  query: (ctx) => optionalString2(ctx, "query"),
+  searchs: (ctx) => optionalJson(ctx, "searchs"),
+  rule: (ctx) => optionalJson(ctx, "rule"),
+  operation_type: (ctx) => optionalString2(ctx, "operation-type"),
+  rule_id: (ctx) => optionalNumber2(ctx, "rule-id"),
+  rule_name: (ctx) => optionalString2(ctx, "rule-name"),
+  comment: (ctx) => optionalString2(ctx, "comment"),
+  node_ids: (ctx) => optionalJsonArray(ctx, "node-ids"),
+  reports_version: (ctx) => optionalNumber2(ctx, "reports-version"),
+  zone_offset: (ctx) => optionalNumber2(ctx, "zone-offset"),
+  schedule_ui_config: (ctx) => optionalJson(ctx, "schedule-ui-config"),
+  dashboard_status: (ctx) => optionalString2(ctx, "dashboard-status"),
+  refresh_type: (ctx) => optionalNumber2(ctx, "refresh-type"),
+  cache_config: (ctx) => optionalJson(ctx, "cache-config"),
+  to_user_id: (ctx) => optionalNumber2(ctx, "to-user-id"),
+  clear_history_tag: (ctx) => optionalNumber2(ctx, "clear-history-tag"),
+  type: (ctx) => optionalString2(ctx, "type"),
+  status: (ctx) => optionalJson(ctx, "status"),
+  sort_field: (ctx) => optionalString2(ctx, "sort-field"),
+  sort_order: (ctx) => optionalString2(ctx, "sort-order"),
+  record_id: (ctx) => optionalNumber2(ctx, "record-id"),
+  limit: (ctx) => optionalNumber2(ctx, "limit"),
+  offset: (ctx) => optionalNumber2(ctx, "offset")
+};
+function assetGovernanceInput(ctx, fields) {
+  const input = {
+    ...projectInput(ctx),
+    payload: optionalJson(ctx, "payload")
+  };
+  for (const field of fields) {
+    input[field] = readers[field]?.(ctx);
+  }
+  return compactInput(input);
+}
+
+// src/commands/te-analysis/meta/asset/url-get.ts
+var analysisMetaAssetUrlGet = createAnalysisMetaCapabilityCommand({
+  resource: "asset",
+  command: "url-get",
+  capabilityId: "analysis_meta.asset_url.get",
+  description: "Get or normalize an asset governance resource link payload.",
+  flags: [projectIdFlag, nodeIdFlag, resourceIdFlag, resourceTypeFlag, linkInfoFlag, payloadFlag],
+  risk: "read",
+  buildInput: (ctx) => assetGovernanceInput(ctx, ["node_id", "resource_id", "resource_type", "link_info"])
+});
+
+// src/commands/te-analysis/meta/asset/index.ts
+var commands6 = [
+  metadataAssetSearch,
+  metadataAssetRecentList,
+  metadataAssetAuthenticationList,
+  metadataAssetAuthenticationUpdate,
+  metadataAssetAbnormalList,
+  metadataAssetAbnormalGet,
+  analysisMetaAssetUrlGet
+];
+var asset_default = commands6;
+
+// src/commands/te-analysis/meta/exchange/config-update.ts
+var metadataExchangeConfigUpdate = createAnalysisMetaCapabilityCommand({
+  resource: "exchange",
+  command: "config-update",
+  capabilityId: "metadata.exchange_config.update",
+  description: "Update exchange-rate configuration switch or value.",
+  flags: [
+    projectIdFlag,
+    { name: "config-val", type: "string", required: true, desc: "Exchange-rate configuration value." }
+  ],
+  risk: "write",
+  buildInput: (ctx) => ({ ...projectInput(ctx), config_val: ctx.str("config-val") })
+});
+
+// src/commands/te-analysis/meta/exchange/rule-list.ts
+var metadataExchangeRuleList = createAnalysisMetaCapabilityCommand({
+  resource: "exchange",
+  command: "rule-list",
+  capabilityId: "metadata.exchange_rule.list",
+  description: "List exchange-rate conversion rules.",
+  flags: [
+    projectIdFlag
+  ],
+  risk: "read",
+  buildInput: projectInput
+});
+
+// src/commands/te-analysis/meta/exchange/rule-validate.ts
+var metadataExchangeRuleValidate = createAnalysisMetaCapabilityCommand({
+  resource: "exchange",
+  command: "rule-validate",
+  capabilityId: "metadata.exchange_rule.validate",
+  description: "Validate affected range before saving exchange-rate rules.",
+  flags: [
+    projectIdFlag,
+    requiredPayloadFlag
+  ],
+  risk: "read",
+  buildInput: (ctx) => ({ ...projectInput(ctx), payload: ctx.json("payload") })
+});
+
+// src/commands/te-analysis/meta/exchange/rule-update.ts
+var metadataExchangeRuleUpdate = createAnalysisMetaCapabilityCommand({
+  resource: "exchange",
+  command: "rule-update",
+  capabilityId: "metadata.exchange_rule.update",
+  description: "Save currency field, amount field, and target currency rules.",
+  flags: [
+    projectIdFlag,
+    requiredPayloadFlag
+  ],
+  risk: "write",
+  buildInput: (ctx) => ({ ...projectInput(ctx), payload: ctx.json("payload") })
+});
+
+// src/commands/te-analysis/meta/exchange/rate-refresh.ts
+var metadataExchangeRateRefresh = createAnalysisMetaCapabilityCommand({
+  resource: "exchange",
+  command: "rate-refresh",
+  capabilityId: "metadata.exchange_rate.refresh",
+  description: "Refresh exchange-rate data manually.",
+  flags: [
+    projectIdFlag
+  ],
+  risk: "write",
+  buildInput: projectInput
+});
+
+// src/commands/te-analysis/meta/exchange/index.ts
+var commands7 = [
+  metadataExchangeConfigUpdate,
+  metadataExchangeRuleList,
+  metadataExchangeRuleValidate,
+  metadataExchangeRuleUpdate,
+  metadataExchangeRateRefresh
+];
+var exchange_default = commands7;
+
+// src/commands/te-analysis/meta/super-metadata/export.ts
+var metadataSuperMetadataExport = createAnalysisMetaCapabilityCommand({
+  resource: "event-property-bundle",
+  command: "export",
+  capabilityId: "metadata.event_property_bundle.export",
+  description: "Export super event and super property configuration as an asynchronous XLSX artifact.",
+  flags: [
+    projectIdFlag,
+    { name: "request-id", type: "string", required: false, desc: "Optional cli_<32 lowercase hex> request ID. Generated when omitted." },
+    { name: "timeout-seconds", type: "number", required: false, desc: "Export timeout seconds. Default and max: 21600 (6 hours).", min: 1, max: 21600 }
+  ],
+  risk: "read",
+  buildInput: (ctx) => compactInput({
+    ...projectInput(ctx),
+    request_id: optionalString2(ctx, "request-id"),
+    timeout_seconds: optionalNumber2(ctx, "timeout-seconds")
+  })
+});
+
+// src/commands/te-analysis/meta/super-metadata/import.ts
+var metadataSuperMetadataImport = createAnalysisMetaCapabilityCommand({
+  resource: "event-property-bundle",
+  command: "import",
+  capabilityId: "metadata.event_property_bundle.import",
+  description: "Pre-import and confirm-import super event and super property configuration.",
+  flags: [
+    projectIdFlag,
+    { name: "operation", type: "string", required: true, desc: "Import step: pre_import or ensure_import." },
+    { name: "input-file-id", type: "string", required: false, desc: "Uploaded XLSX input file ID for pre_import. Upload with purpose=event_property_bundle.import.xlsx." },
+    { name: "pre-import-meta-uuid", type: "string", required: false, desc: "UUID returned by pre_import, required for ensure_import." }
+  ],
+  risk: "write",
+  buildInput: (ctx) => compactInput({
+    ...projectInput(ctx),
+    operation: ctx.str("operation"),
+    input_file_id: optionalString2(ctx, "input-file-id"),
+    pre_import_meta_uuid: optionalString2(ctx, "pre-import-meta-uuid")
+  })
+});
+
+// src/commands/te-analysis/meta/super-metadata/index.ts
+var commands8 = [
+  metadataSuperMetadataExport,
+  metadataSuperMetadataImport
+];
+var super_metadata_default = commands8;
+
+// src/commands/te-analysis/meta/datatable/columns-get.ts
+var metadataDataTableColumnsGet = createAnalysisMetaCapabilityCommand({
+  resource: "datatable",
+  command: "columns-get",
+  capabilityId: "metadata.data_table.columns_get",
+  description: "Get columns for a project table reference.",
+  flags: [
+    projectIdFlag,
+    { name: "table-ref", type: "string", required: true, desc: "Project table reference." }
+  ],
+  risk: "read",
+  buildInput: (ctx) => ({ ...projectInput(ctx), table_ref: ctx.str("table-ref") })
+});
+
+// src/commands/te-analysis/meta/datatable/influence-list.ts
+var metadataDataTableInfluenceList = createAnalysisMetaCapabilityCommand({
+  resource: "datatable",
+  command: "influence-list",
+  capabilityId: "metadata.data_table.influence_list",
+  description: "List metadata and assets affected by data table deletion or column changes.",
+  flags: [
+    projectIdFlag,
+    { name: "datatable-id", type: "number", required: true, desc: "Data table ID." }
+  ],
+  risk: "read",
+  buildInput: (ctx) => ({ ...projectInput(ctx), datatable_id: ctx.num("datatable-id") })
+});
+
+// src/commands/te-analysis/meta/datatable/version-list.ts
+var metadataDataTableVersionList = createAnalysisMetaCapabilityCommand({
+  resource: "datatable",
+  command: "version-list",
+  capabilityId: "metadata.data_table_version.list",
+  description: "List data table historical versions.",
+  flags: [
+    projectIdFlag,
+    { name: "datatable-id", type: "number", required: true, desc: "Data table ID." }
+  ],
+  risk: "read",
+  buildInput: (ctx) => ({ ...projectInput(ctx), datatable_id: ctx.num("datatable-id") })
+});
+
+// src/commands/te-analysis/meta/datatable/version-get.ts
+var metadataDataTableVersionGet = createAnalysisMetaCapabilityCommand({
+  resource: "datatable",
+  command: "version-get",
+  capabilityId: "metadata.data_table_version.get",
+  description: "Get data table version detail.",
+  flags: [
+    projectIdFlag,
+    { name: "version-id", type: "number", required: true, desc: "Data table version ID." }
+  ],
+  risk: "read",
+  buildInput: (ctx) => ({ ...projectInput(ctx), version_id: ctx.num("version-id") })
+});
+
+// src/commands/te-analysis/meta/datatable/index.ts
+var commands9 = [
+  metadataDataTableColumnsGet,
+  metadataDataTableInfluenceList,
+  metadataDataTableVersionList,
+  metadataDataTableVersionGet
+];
+var datatable_default = commands9;
+
+// src/commands/te-analysis/meta/index.ts
+var commands10 = [
+  getAlertDefinitionSchema,
+  listAlerts,
+  getAlert,
+  createAlert,
+  updateAlert,
+  deleteAlert,
+  ...event_default,
+  ...property_default,
+  ...virtual_event_default,
+  ...virtual_property_default,
+  ...metric_default,
+  ...asset_default,
+  ...exchange_default,
+  ...super_metadata_default,
+  ...datatable_default
+];
+var meta_default = commands10;
+
+// src/commands/te-analysis/meta/asset/usage-list.ts
+var analysisMetaAssetUsageList = createAnalysisGovernanceCapabilityCommand({
+  resource: "asset",
+  command: "list",
+  capabilityId: "governance.asset.list",
+  description: "List assets for usage governance.",
+  flags: [projectIdFlag, queryFlag, searchsFlag, ruleFlag, operationTypeFlag, directoryLimitFlag, offsetFlag, payloadFlag],
+  risk: "read",
+  buildInput: (ctx) => assetGovernanceInput(ctx, ["query", "searchs", "rule", "operation_type", "limit", "offset"])
+});
+
+// src/commands/te-analysis/meta/asset/usage-export.ts
+var analysisMetaAssetUsageExport = createAnalysisGovernanceCapabilityCommand({
+  resource: "asset",
+  command: "export",
+  capabilityId: "governance.asset.export",
+  description: "Export asset usage governance rows as an inline gateway result.",
+  flags: [projectIdFlag, queryFlag, searchsFlag, ruleFlag, operationTypeFlag, limitFlag, offsetFlag, payloadFlag],
+  risk: "read",
+  buildInput: (ctx) => assetGovernanceInput(ctx, ["query", "searchs", "rule", "operation_type", "limit", "offset"])
+});
+
+// src/commands/te-analysis/meta/asset/lineage-get.ts
+var analysisMetaAssetLineageGet = createAnalysisGovernanceCapabilityCommand({
+  resource: "asset-lineage",
+  command: "get",
+  capabilityId: "governance.asset_lineage.get",
+  description: "Get an asset lineage tree.",
+  flags: [projectIdFlag, nodeIdFlag, payloadFlag],
+  risk: "read",
+  buildInput: (ctx) => assetGovernanceInput(ctx, ["node_id"])
+});
+
+// src/commands/te-analysis/meta/asset/dependency-list.ts
+var analysisMetaAssetDependencyList = createAnalysisGovernanceCapabilityCommand({
+  resource: "asset-dependency",
+  command: "list",
+  capabilityId: "governance.asset_dependency.list",
+  description: "List upstream dependencies for one asset.",
+  flags: [projectIdFlag, nodeIdFlag, queryFlag, searchsFlag, ruleFlag, directoryLimitFlag, offsetFlag, payloadFlag],
+  risk: "read",
+  buildInput: (ctx) => assetGovernanceInput(ctx, ["node_id", "query", "searchs", "rule", "limit", "offset"])
+});
+
+// src/commands/te-analysis/meta/asset/impact-list.ts
+var analysisMetaAssetImpactList = createAnalysisGovernanceCapabilityCommand({
+  resource: "asset-impact",
+  command: "list",
+  capabilityId: "governance.asset_impact.list",
+  description: "List downstream impacts for one asset.",
+  flags: [projectIdFlag, nodeIdFlag, queryFlag, searchsFlag, ruleFlag, directoryLimitFlag, offsetFlag, payloadFlag],
+  risk: "read",
+  buildInput: (ctx) => assetGovernanceInput(ctx, ["node_id", "query", "searchs", "rule", "limit", "offset"])
+});
+
+// src/commands/te-analysis/meta/asset/query-history-list.ts
+var analysisMetaAssetQueryHistoryList = createAnalysisGovernanceCapabilityCommand({
+  resource: "asset-query-history",
+  command: "list",
+  capabilityId: "governance.asset_query_history.list",
+  description: "List query history for one asset.",
+  flags: [projectIdFlag, nodeIdFlag, queryFlag, searchsFlag, ruleFlag, directoryLimitFlag, offsetFlag, payloadFlag],
+  risk: "read",
+  buildInput: (ctx) => assetGovernanceInput(ctx, ["node_id", "query", "searchs", "rule", "limit", "offset"])
+});
+
+// src/commands/te-analysis/meta/asset/rule-schema.ts
+var analysisMetaAssetRuleSchema = createAnalysisGovernanceCapabilityCommand({
+  resource: "rule",
+  command: "schema",
+  capabilityId: "governance.rule.schema",
+  description: "Get asset governance rule field schema.",
+  flags: [projectIdFlag, payloadFlag],
+  risk: "read",
+  buildInput: (ctx) => assetGovernanceInput(ctx, [])
+});
+
+// src/commands/te-analysis/meta/asset/rule-list.ts
+var analysisMetaAssetRuleList = createAnalysisGovernanceCapabilityCommand({
+  resource: "rule",
+  command: "list",
+  capabilityId: "governance.rule.list",
+  description: "List asset governance rules.",
+  flags: [projectIdFlag, payloadFlag],
+  risk: "read",
+  buildInput: (ctx) => assetGovernanceInput(ctx, [])
+});
+
+// src/commands/te-analysis/meta/asset/rule-create.ts
+var analysisMetaAssetRuleCreate = createAnalysisGovernanceCapabilityCommand({
+  resource: "rule",
+  command: "create",
+  capabilityId: "governance.rule.create",
+  description: "Create an asset governance rule.",
+  flags: [projectIdFlag, ruleNameFlag, commentFlag, ruleFlag, payloadFlag],
+  risk: "write",
+  buildInput: (ctx) => assetGovernanceInput(ctx, ["rule_name", "comment", "rule"])
+});
+
+// src/commands/te-analysis/meta/asset/rule-update.ts
+var analysisMetaAssetRuleUpdate = createAnalysisGovernanceCapabilityCommand({
+  resource: "rule",
+  command: "update",
+  capabilityId: "governance.rule.update",
+  description: "Update an asset governance rule.",
+  flags: [projectIdFlag, ruleIdFlag, ruleNameFlag, commentFlag, ruleFlag, payloadFlag],
+  risk: "write",
+  buildInput: (ctx) => assetGovernanceInput(ctx, ["rule_id", "rule_name", "comment", "rule"])
+});
+
+// src/commands/te-analysis/meta/asset/rule-delete.ts
+var analysisMetaAssetRuleDelete = createAnalysisGovernanceCapabilityCommand({
+  resource: "rule",
+  command: "delete",
+  capabilityId: "governance.rule.delete",
+  description: "Delete an asset governance rule.",
+  flags: [projectIdFlag, ruleIdFlag, payloadFlag],
+  risk: "high-risk-write",
+  buildInput: (ctx) => assetGovernanceInput(ctx, ["rule_id"])
+});
+
+// src/commands/te-analysis/meta/asset/batch-info-export.ts
+var analysisMetaAssetBatchInfoExport = createAnalysisGovernanceCapabilityCommand({
+  resource: "asset",
+  command: "batch-info-export",
+  capabilityId: "governance.asset.batch_export_info",
+  description: "Batch export asset information.",
+  flags: [projectIdFlag, nodeIdsFlag, reportsVersionFlag, zoneOffsetFlag, scheduleUiConfigFlag, dashboardStatusFlag, refreshTypeFlag, cacheConfigFlag, clearHistoryTagFlag, payloadFlag],
+  risk: "read",
+  buildInput: (ctx) => assetGovernanceInput(ctx, ["node_ids", "reports_version", "zone_offset", "schedule_ui_config", "dashboard_status", "refresh_type", "cache_config", "clear_history_tag"])
+});
+
+// src/commands/te-analysis/meta/asset/batch-sql-export.ts
+var analysisMetaAssetBatchSqlExport = createAnalysisGovernanceCapabilityCommand({
+  resource: "asset",
+  command: "batch-sql-export",
+  capabilityId: "governance.asset.batch_export_sql",
+  description: "Batch export asset SQL definitions.",
+  flags: [projectIdFlag, nodeIdsFlag, reportsVersionFlag, zoneOffsetFlag, scheduleUiConfigFlag, dashboardStatusFlag, refreshTypeFlag, cacheConfigFlag, clearHistoryTagFlag, payloadFlag],
+  risk: "read",
+  buildInput: (ctx) => assetGovernanceInput(ctx, ["node_ids", "reports_version", "zone_offset", "schedule_ui_config", "dashboard_status", "refresh_type", "cache_config", "clear_history_tag"])
+});
+
+// src/commands/te-analysis/meta/asset/batch-delete.ts
+var analysisMetaAssetBatchDelete = createAnalysisGovernanceCapabilityCommand({
+  resource: "asset",
+  command: "batch-delete",
+  capabilityId: "governance.asset.batch_delete",
+  description: "Batch delete governed assets.",
+  flags: [projectIdFlag, nodeIdsFlag, payloadFlag],
+  risk: "high-risk-write",
+  buildInput: (ctx) => assetGovernanceInput(ctx, ["node_ids"])
+});
+
+// src/commands/te-analysis/meta/asset/batch-disable-auto-update.ts
+var analysisMetaAssetBatchDisableAutoUpdate = createAnalysisGovernanceCapabilityCommand({
+  resource: "asset",
+  command: "batch-disable-auto-update",
+  capabilityId: "governance.asset.batch_disable_auto_update",
+  description: "Batch disable auto update for assets.",
+  flags: [projectIdFlag, nodeIdsFlag, refreshTypeFlag, payloadFlag],
+  risk: "write",
+  buildInput: (ctx) => assetGovernanceInput(ctx, ["node_ids", "refresh_type"])
+});
+
+// src/commands/te-analysis/meta/asset/batch-disable-auto-backup.ts
+var analysisMetaAssetBatchDisableAutoBackup = createAnalysisGovernanceCapabilityCommand({
+  resource: "asset",
+  command: "batch-disable-auto-backup",
+  capabilityId: "governance.asset.batch_disable_auto_backup",
+  description: "Batch disable auto backup for assets.",
+  flags: [projectIdFlag, nodeIdsFlag, clearHistoryTagFlag, payloadFlag],
+  risk: "write",
+  buildInput: (ctx) => assetGovernanceInput(ctx, ["node_ids", "clear_history_tag"])
+});
+
+// src/commands/te-analysis/meta/asset/batch-dashboard-schedule-freeze.ts
+var analysisMetaAssetBatchDashboardScheduleFreeze = createAnalysisGovernanceCapabilityCommand({
+  resource: "asset",
+  command: "batch-dashboard-schedule-freeze",
+  capabilityId: "governance.asset.batch_dashboard_schedule_freeze",
+  description: "Batch freeze dashboard schedules for governed assets.",
+  flags: [projectIdFlag, nodeIdsFlag, reportsVersionFlag, zoneOffsetFlag, scheduleUiConfigFlag, dashboardStatusFlag, refreshTypeFlag, cacheConfigFlag, payloadFlag],
+  risk: "write",
+  buildInput: (ctx) => assetGovernanceInput(ctx, ["node_ids", "reports_version", "zone_offset", "schedule_ui_config", "dashboard_status", "refresh_type", "cache_config"])
+});
+
+// src/commands/te-analysis/meta/asset/batch-handover.ts
+var analysisMetaAssetBatchHandover = createAnalysisGovernanceCapabilityCommand({
+  resource: "asset",
+  command: "batch-handover",
+  capabilityId: "governance.asset.batch_handover",
+  description: "Batch hand over governed assets to another user.",
+  flags: [projectIdFlag, nodeIdsFlag, toUserIdFlag, payloadFlag],
+  risk: "write",
+  buildInput: (ctx) => assetGovernanceInput(ctx, ["node_ids", "to_user_id"])
+});
+
+// src/commands/te-analysis/meta/asset/operation-record-list.ts
+var analysisMetaAssetOperationRecordList = createAnalysisGovernanceCapabilityCommand({
+  resource: "operation-record",
+  command: "list",
+  capabilityId: "governance.operation_record.list",
+  description: "List asset batch operation records.",
+  flags: [projectIdFlag, typeFlag, statusFlag, queryFlag, sortFieldFlag, sortOrderFlag, directoryLimitFlag, offsetFlag, payloadFlag],
+  risk: "read",
+  buildInput: (ctx) => assetGovernanceInput(ctx, ["type", "status", "query", "sort_field", "sort_order", "limit", "offset"])
+});
+
+// src/commands/te-analysis/meta/asset/operation-record-export.ts
+var analysisMetaAssetOperationRecordExport = createAnalysisGovernanceCapabilityCommand({
+  resource: "operation-record",
+  command: "export",
+  capabilityId: "governance.operation_record.export",
+  description: "Export one asset batch operation record result.",
+  flags: [projectIdFlag, recordIdFlag, payloadFlag],
+  risk: "read",
+  buildInput: (ctx) => assetGovernanceInput(ctx, ["record_id"])
+});
+
+// src/commands/te-analysis/governance/index.ts
+var commands11 = [
+  analysisMetaAssetUsageList,
+  analysisMetaAssetUsageExport,
+  analysisMetaAssetBatchInfoExport,
+  analysisMetaAssetBatchSqlExport,
+  analysisMetaAssetBatchDelete,
+  analysisMetaAssetBatchDisableAutoUpdate,
+  analysisMetaAssetBatchDisableAutoBackup,
+  analysisMetaAssetBatchDashboardScheduleFreeze,
+  analysisMetaAssetBatchHandover,
+  analysisMetaAssetLineageGet,
+  analysisMetaAssetDependencyList,
+  analysisMetaAssetImpactList,
+  analysisMetaAssetQueryHistoryList,
+  analysisMetaAssetRuleSchema,
+  analysisMetaAssetRuleList,
+  analysisMetaAssetRuleCreate,
+  analysisMetaAssetRuleUpdate,
+  analysisMetaAssetRuleDelete,
+  analysisMetaAssetOperationRecordList,
+  analysisMetaAssetOperationRecordExport
+];
+var governance_default = commands11;
+
+// src/commands/te-analysis/report/list.ts
+var reportList = createAnalysisCapabilityCommand({
+  resource: "report",
+  command: "list",
+  capabilityId: "analysis.report.list",
+  description: "List analysis reports visible to the current user through the capability gateway.",
+  flags: [projectIdFlag, queryFlag, fieldsFlag, reportModelTypesFlag, reportListLimitFlag, offsetFlag],
+  risk: "read",
+  buildInput: reportListInput
+});
+
+// src/commands/te-analysis/report/list-export.ts
+var reportListExport = createAnalysisCapabilityCommand({
+  resource: "report",
+  command: "list-export",
+  capabilityId: "analysis.report.list_export",
+  description: "Export the accessible report catalog as a gzip artifact.",
+  flags: [
+    projectIdFlag,
+    queryFlag,
+    fieldsFlag,
+    reportModelTypesFlag,
+    requestIdFlag,
+    artifactFormatFlag,
+    asyncTimeoutSecondsFlag
+  ],
+  risk: "read",
+  buildInput: (ctx) => compactInput({
+    ...projectInput(ctx),
+    query: optionalString2(ctx, "query"),
+    fields: optionalJson(ctx, "fields"),
+    model_types: optionalJson(ctx, "model-types"),
+    ...exportLifecycleInput(ctx)
+  })
+});
+
+// src/commands/te-analysis/report/get.ts
+var reportGet = createAnalysisCapabilityCommand({
+  resource: "report",
+  command: "get",
+  capabilityId: "analysis.report.get",
+  description: "Get one analysis report definition as AI QP without executing report data.",
+  flags: [projectIdFlag, { name: "report-id", type: "number", required: true, desc: "Report ID." }],
+  risk: "read",
+  buildInput: (ctx) => ({
+    ...projectInput(ctx),
+    report_id: ctx.num("report-id")
+  })
+});
+
+// src/commands/te-analysis/ai-models.ts
+var AI_MODEL_TYPE_VALUES = [
+  "event",
+  "retention",
+  "funnel",
+  "distribution",
+  "attribution",
+  "interval",
+  "path",
+  "prop_analysis",
+  "sql",
+  "heat_map",
+  "rank_list",
+  "revenue"
+];
+var AI_MODEL_DESCRIPTION = "Supported AI-facing model_type values, 12 total. 9 common models: event (event analysis), retention (retention analysis), funnel (funnel conversion), distribution (distribution analysis), attribution (attribution analysis), interval (interval analysis), path (path analysis), prop_analysis (property analysis), sql (SQL analysis). 3 scenario models: heat_map (heat map analysis), rank_list (ranking analysis), revenue (revenue analysis). Tags and cohorts/clusters are separate capabilities and are not ad-hoc model_type values.";
+var REPORT_WRITE_MODEL_TYPE_VALUES = [
+  ...AI_MODEL_TYPE_VALUES,
+  "tag"
+];
+var REPORT_WRITE_MODEL_DESCRIPTION = `${AI_MODEL_DESCRIPTION} Report create/update also supports tag for saved tag report data; use tag as the AI-facing spelling.`;
+var AI_DEFINITION_DESCRIPTION = 'AI-facing model definition JSON. Do not pass raw QP, events, event_view, visual_view, or analysis_query. For SQL, a simple query is {"sql":"select ..."}; raw variables use ${name}, while typed params use ${Text:name}, ${Selector:name}, or ${PartDate:name}. PartDate expands to a complete predicate, so write WHERE ${PartDate:d}, not a column followed by the placeholder. Selector value must match one options[].value. Trino identifiers containing #, $, @, spaces, or punctuation must be delimited with double quotes, for example SELECT "#user_id", "$part_event" FROM ...; single quotes are string literals. Queries against an event table must include a date-partition predicate on the quoted "$part_date" column, for example WHERE "$part_date" BETWEEN \'2026-07-01\' AND \'2026-07-07\'; the backend rejects event-table SQL without it. The CLI preserves SQL text and never auto-quotes identifiers.';
+var REPORT_WRITE_DEFINITION_DESCRIPTION = `${AI_DEFINITION_DESCRIPTION} For model_type=tag, pass a tag report intent such as {"tag":{"tag_name":"vip_users","time_range":{"mode":"recent","unit":"day","value":7}}}. Tags are supported for report create/update and report data, not ad-hoc analysis.`;
+function aiModelTypeFlag(required) {
+  return {
+    name: "model-type",
+    type: "string",
+    required,
+    desc: AI_MODEL_DESCRIPTION
+  };
+}
+function reportWriteModelTypeFlag(required) {
+  return {
+    name: "model-type",
+    type: "string",
+    required,
+    desc: REPORT_WRITE_MODEL_DESCRIPTION
+  };
+}
+function aiDefinitionFlag(required) {
+  return {
+    name: "definition",
+    type: "json",
+    required,
+    desc: AI_DEFINITION_DESCRIPTION
+  };
+}
+function reportWriteDefinitionFlag(required) {
+  return {
+    name: "definition",
+    type: "json",
+    required,
+    desc: REPORT_WRITE_DEFINITION_DESCRIPTION
+  };
+}
+
+// src/commands/te-analysis/report/create.ts
+var reportCreate = createAnalysisCapabilityCommand({
+  resource: "report",
+  command: "create",
+  capabilityId: "analysis.report.create",
+  description: "Create an analysis report from an AI QP model_type and definition.",
+  flags: [
+    projectIdFlag,
+    { name: "report-name", type: "string", required: true, desc: "Report display name." },
+    reportWriteModelTypeFlag(true),
+    reportWriteDefinitionFlag(true),
+    { name: "report-desc", type: "string", required: false, desc: "Optional report description." },
+    { name: "cache-seconds", type: "number", required: false, desc: "Optional cache duration in seconds." },
+    { name: "query-duration-ms", type: "number", required: false, desc: "Optional last query duration in milliseconds." },
+    { name: "dashboard-ids", type: "json", required: false, desc: "Optional dashboard ID array to associate after creation." }
+  ],
+  risk: "write",
+  buildInput: (ctx) => compactInput({
+    ...projectInput(ctx),
+    report_name: ctx.str("report-name"),
+    model_type: ctx.str("model-type"),
+    definition: ctx.json("definition"),
+    report_desc: optionalString2(ctx, "report-desc"),
+    cache_seconds: optionalNumber2(ctx, "cache-seconds"),
+    query_duration_ms: optionalNumber2(ctx, "query-duration-ms"),
+    dashboard_ids: optionalJsonArray(ctx, "dashboard-ids")
+  })
+});
+
+// src/commands/te-analysis/report/update.ts
+function validateReportUpdate(ctx) {
+  const hasDefinition = ctx.str("definition") !== "";
+  const hasMetadataUpdate = ctx.str("report-name") !== "" || ctx.str("report-desc") !== "";
+  if (!hasDefinition && !hasMetadataUpdate) {
+    throw new Error("At least one of --report-name, --report-desc, or --definition is required.");
+  }
+  if (hasDefinition && ctx.str("model-type") === "") {
+    throw new Error("--model-type is required when --definition is provided.");
+  }
+}
+var reportUpdate = createAnalysisCapabilityCommand({
+  resource: "report",
+  command: "update",
+  capabilityId: "analysis.report.update",
+  description: "Update report metadata or AI QP definition through the capability gateway.",
+  flags: [
+    projectIdFlag,
+    { name: "report-id", type: "number", required: true, desc: "Report ID to update." },
+    { name: "report-version", type: "number", required: true, desc: "Current report version from report get." },
+    { name: "report-name", type: "string", required: false, desc: "New report display name." },
+    { name: "report-desc", type: "string", required: false, desc: "New report description." },
+    reportWriteModelTypeFlag(false),
+    reportWriteDefinitionFlag(false),
+    { name: "cache-seconds", type: "number", required: false, desc: "Optional cache duration in seconds." },
+    { name: "query-duration-ms", type: "number", required: false, desc: "Optional last query duration in milliseconds." }
+  ],
+  risk: "write",
+  validate: validateReportUpdate,
+  buildInput: (ctx) => compactInput({
+    ...projectInput(ctx),
+    report_id: ctx.num("report-id"),
+    version: ctx.num("report-version"),
+    report_name: optionalString2(ctx, "report-name"),
+    report_desc: optionalString2(ctx, "report-desc"),
+    model_type: optionalString2(ctx, "model-type"),
+    definition: optionalJson(ctx, "definition"),
+    cache_seconds: optionalNumber2(ctx, "cache-seconds"),
+    query_duration_ms: optionalNumber2(ctx, "query-duration-ms")
+  })
+});
+
+// src/commands/te-analysis/report/delete.ts
+var reportDelete = createAnalysisCapabilityCommand({
+  resource: "report",
+  command: "delete",
+  capabilityId: "analysis.report.delete",
+  description: "Delete one or more analysis reports.",
+  flags: [projectIdFlag, { name: "report-ids", type: "json", required: true, desc: "Report ID array." }],
+  risk: "high-risk-write",
+  buildInput: (ctx) => ({
+    ...projectInput(ctx),
+    report_ids: jsonArray(ctx, "report-ids")
+  })
+});
+
+// src/commands/te-analysis/report/index.ts
+var commands12 = [
+  reportList,
+  reportListExport,
+  reportGet,
+  reportCreate,
+  reportUpdate,
+  reportDelete
+];
+var report_default = commands12;
+
+// src/commands/te-analysis/report-data/shared.ts
+function reportDataInput(ctx) {
+  return compactInput({
+    ...projectInput(ctx),
+    report_ids: jsonArray(ctx, "report-ids"),
+    request_id: optionalString2(ctx, "request-id"),
+    filters: optionalJson(ctx, "filters"),
+    group_by: optionalJson(ctx, "group-by"),
+    sql_params: optionalJson(ctx, "sql-params"),
+    start_time: optionalString2(ctx, "start-time"),
+    end_time: optionalString2(ctx, "end-time"),
+    time_granularity: optionalString2(ctx, "time-granularity"),
+    zone_offset: optionalNumber2(ctx, "zone-offset"),
+    use_cache: optionalBoolean2(ctx, "use-cache"),
+    limit: optionalNumber2(ctx, "limit"),
+    timeout_seconds: optionalNumber2(ctx, "timeout-seconds")
+  });
+}
+function reportDataExportInput(ctx) {
+  return compactInput({
+    ...reportDataInput(ctx),
+    limit: void 0,
+    ...exportLifecycleInput(ctx)
+  });
+}
+
+// src/commands/te-analysis/report-data/run.ts
+var reportDataRun = createAnalysisCapabilityCommand({
+  resource: "report-data",
+  command: "run",
+  capabilityId: "analysis.report_data.run",
+  description: `Run a bounded report data query. Override contract: SQL uses only --sql-params; non-SQL analysis models use filters/group/time; tag uses its saved tag definition. Mixed-model batches continue with structured warnings for ignored fields. ${analysisDataRunRoutingHelp}`,
+  flags: [
+    projectIdFlag,
+    { name: "report-ids", type: "json", required: true, desc: "Report ID array. With overrides, prefer one model per batch; mixed models still return data and meta.warnings identifies report_ids and ignored_fields." },
+    requestIdFlag,
+    { name: "filters", type: "json", required: false, desc: 'Non-SQL analysis models only. SQL-only requests reject this field; mixed batches warn for SQL report_ids that ignore it. AI-facing shape: {"relation":"and","items":[{"field":{"name":"country","type":"user_property"},"operator":"eq","values":["US"]}]}. Never pass QP taFilters.' },
+    { name: "group-by", type: "json", required: false, desc: 'Non-SQL analysis models only. SQL-only requests reject this field; mixed batches warn. AI-facing shape: [{"field":{"name":"country","type":"user_property"}}]. Time granularity uses --time-granularity.' },
+    { name: "sql-params", type: "json", required: false, desc: 'SQL reports only. First run analysis report get for every target SQL report; each name must exist in every definition.params. Send value overrides only, for example [{"name":"platform","value":"ios"}] or saved part_date/time parameters with start_time/end_time. Do not send definition fields such as paramType or selectorItems.' },
+    { name: "start-time", type: "string", required: false, desc: "Non-SQL analysis-model date override start, yyyy-MM-dd. SQL dates must be saved parameters overridden through --sql-params." },
+    { name: "end-time", type: "string", required: false, desc: "Non-SQL analysis-model date override end, yyyy-MM-dd. SQL dates must be saved parameters overridden through --sql-params." },
+    { name: "time-granularity", type: "string", required: false, desc: "Non-SQL analysis-model time granularity override. SQL accepts only --sql-params." },
+    { name: "zone-offset", type: "number", required: false, desc: "Query execution timezone offset in hours. This is not persisted in the report definition." },
+    { name: "use-cache", type: "boolean", required: false, desc: "Whether to use cache. Default: true." },
+    syncLimitFlag,
+    syncTimeoutSecondsFlag
+  ],
+  risk: "read",
+  buildInput: reportDataInput,
+  postProcess: applyAnalysisInlineLimit
+});
+
+// src/commands/te-analysis/report-data/export.ts
+var reportDataExport = createAnalysisCapabilityCommand({
+  resource: "report-data",
+  command: "export",
+  capabilityId: "analysis.report_data.export",
+  description: `Submit report data as an asynchronous gzip artifact. Override contract: SQL uses only --sql-params; non-SQL analysis models use filters/group/time; tag uses its saved tag definition. Mixed-model batches are best-effort. The submit response and artifact metadata line contain query_context_id when Redis context creation succeeds. ${analysisDataExportRoutingHelp}`,
+  flags: [
+    projectIdFlag,
+    { name: "report-ids", type: "json", required: true, desc: "Report ID array. With overrides, prefer one model per batch so every field has the same meaning." },
+    requestIdFlag,
+    { name: "filters", type: "json", required: false, desc: "Non-SQL analysis models only. SQL-only requests reject this field; mixed batches are best-effort. Use AI-facing field intent, never QP taFilters." },
+    { name: "group-by", type: "json", required: false, desc: 'Non-SQL analysis models only. SQL-only requests reject this field. Shape: [{"field":{"name":"country","type":"user_property"}}].' },
+    { name: "sql-params", type: "json", required: false, desc: "SQL reports only. First run analysis report get for every target SQL report; each name must exist in every definition.params. Send value overrides only, including saved part_date/time parameters for date changes. Do not send definition fields such as paramType or selectorItems." },
+    { name: "start-time", type: "string", required: false, desc: "Non-SQL analysis-model date override start, yyyy-MM-dd. SQL dates use --sql-params." },
+    { name: "end-time", type: "string", required: false, desc: "Non-SQL analysis-model date override end, yyyy-MM-dd. SQL dates use --sql-params." },
+    { name: "time-granularity", type: "string", required: false, desc: "Non-SQL analysis-model time granularity override. SQL accepts only --sql-params." },
+    { name: "zone-offset", type: "number", required: false, desc: "Query execution timezone offset in hours. This is not persisted in the report definition." },
+    { name: "use-cache", type: "boolean", required: false, desc: "Whether to use cache. Default: true." },
+    artifactFormatFlag,
+    asyncTimeoutSecondsFlag
+  ],
+  risk: "read",
+  buildInput: reportDataExportInput
+});
+
+// src/commands/te-analysis/report-data/index.ts
+var commands13 = [
+  reportDataRun,
+  reportDataExport
+];
+var report_data_default = commands13;
+
+// src/commands/te-analysis/report-change-log/list.ts
+var reportChangeLogList = createAnalysisCapabilityCommand({
+  resource: "report-change-log",
+  command: "list",
+  capabilityId: "analysis.report_change_log.list",
+  description: "List change logs for one analysis report.",
+  flags: [projectIdFlag, { name: "report-id", type: "number", required: true, desc: "Report ID." }],
+  risk: "read",
+  buildInput: (ctx) => ({
+    ...projectInput(ctx),
+    report_id: ctx.num("report-id")
+  })
+});
+
+// src/commands/te-analysis/report-change-log/get.ts
+var reportChangeLogGet = createAnalysisCapabilityCommand({
+  resource: "report-change-log",
+  command: "get",
+  capabilityId: "analysis.report_change_log.get",
+  description: "Get one report change log detail as an AI QP definition when available.",
+  flags: [
+    projectIdFlag,
+    { name: "report-id", type: "number", required: true, desc: "Report ID." },
+    { name: "history-version", type: "number", required: false, desc: "Optional history version. Omit for latest." }
+  ],
+  risk: "read",
+  buildInput: (ctx) => compactInput({
+    ...projectInput(ctx),
+    report_id: ctx.num("report-id"),
+    version: optionalNumber2(ctx, "history-version")
+  })
+});
+
+// src/commands/te-analysis/report-change-log/index.ts
+var commands14 = [
+  reportChangeLogList,
+  reportChangeLogGet
+];
+var report_change_log_default = commands14;
+
+// src/commands/te-analysis/report-version/rollback.ts
+var reportVersionRollback = createAnalysisCapabilityCommand({
+  resource: "report-version",
+  command: "rollback",
+  capabilityId: "analysis.report_version.rollback",
+  description: "Rollback an analysis report to a previous history version.",
+  flags: [
+    projectIdFlag,
+    { name: "report-id", type: "number", required: true, desc: "Report ID." },
+    { name: "target-version", type: "number", required: true, desc: "History version to rollback to." }
+  ],
+  risk: "write",
+  buildInput: (ctx) => ({
+    ...projectInput(ctx),
+    report_id: ctx.num("report-id"),
+    version: ctx.num("target-version")
+  })
+});
+
+// src/commands/te-analysis/report-version/index.ts
+var commands15 = [
+  reportVersionRollback
+];
+var report_version_default = commands15;
+
+// src/commands/te-analysis/report-abnormal/get.ts
+var reportAbnormalGet = createAnalysisCapabilityCommand({
+  resource: "report-abnormal",
+  command: "get",
+  capabilityId: "analysis.report_abnormal.get",
+  description: "Get abnormal asset information for one analysis report.",
+  flags: [projectIdFlag, { name: "report-id", type: "number", required: true, desc: "Report ID." }],
+  risk: "read",
+  buildInput: (ctx) => ({
+    ...projectInput(ctx),
+    report_id: ctx.num("report-id")
+  })
+});
+
+// src/commands/te-analysis/report-abnormal/index.ts
+var commands16 = [
+  reportAbnormalGet
+];
+var report_abnormal_default = commands16;
+
+// src/commands/te-analysis/dashboard/list.ts
+var dashboardList = createAnalysisCapabilityCommand({
+  resource: "dashboard",
+  command: "list",
+  capabilityId: "analysis.dashboard.list",
+  description: "List dashboards visible to the current user through the capability gateway.",
+  flags: [
+    projectIdFlag,
+    queryFlag,
+    {
+      name: "fields",
+      type: "json",
+      required: false,
+      desc: "Optional projection field array. Supported fields: dashboard_id, dashboard_name, remark.",
+      alias: "f"
+    },
+    directoryLimitFlag,
+    offsetFlag
+  ],
+  risk: "read",
+  buildInput: listInput
+});
+
+// src/commands/te-analysis/dashboard/create.ts
+var dashboardCreate = createAnalysisCapabilityCommand({
+  resource: "dashboard",
+  command: "create",
+  capabilityId: "analysis.dashboard.create",
+  description: "Create a dashboard in personal space, project space, or a folder.",
+  flags: [
+    projectIdFlag,
+    { name: "dashboard-name", type: "string", required: true, desc: "Dashboard name." },
+    { name: "space-id", type: "number", required: false, desc: "Target project space ID. Omit for personal space." },
+    { name: "folder-id", type: "number", required: false, desc: "Target folder ID." },
+    { name: "initial-report-id", type: "number", required: false, desc: "Optional report ID to add when creating the dashboard." },
+    payloadFlag
+  ],
+  risk: "write",
+  buildInput: (ctx) => compactInput({
+    ...projectInput(ctx),
+    dashboard_name: ctx.str("dashboard-name"),
+    space_id: optionalNumber2(ctx, "space-id"),
+    folder_id: optionalNumber2(ctx, "folder-id"),
+    initial_report_id: optionalNumber2(ctx, "initial-report-id"),
+    payload: optionalJson(ctx, "payload")
+  })
+});
+
+// src/commands/te-analysis/dashboard/get.ts
+var dashboardGet = createAnalysisCapabilityCommand({
+  resource: "dashboard",
+  command: "get",
+  capabilityId: "analysis.dashboard.get",
+  description: "Get one dashboard detail, including creator, create/update time, settings, reports, notes, and share information.",
+  flags: [
+    projectIdFlag,
+    { name: "dashboard-id", type: "number", required: true, desc: "Dashboard ID." },
+    { name: "use-cache", type: "boolean", required: false, desc: "Whether to use cached dashboard detail. Default: true." }
+  ],
+  risk: "read",
+  buildInput: (ctx) => compactInput({
+    ...projectInput(ctx),
+    dashboard_id: ctx.num("dashboard-id"),
+    use_cache: optionalBoolean2(ctx, "use-cache")
+  })
+});
+
+// src/commands/te-analysis/dashboard/update.ts
+var dashboardUpdate = createAnalysisCapabilityCommand({
+  resource: "dashboard",
+  command: "update",
+  capabilityId: "analysis.dashboard.update",
+  description: "Update dashboard settings or create/update a dashboard note. Use --operation settings or note-upsert.",
+  flags: [
+    projectIdFlag,
+    { name: "operation", type: "string", required: true, desc: "Update operation: settings or note-upsert." },
+    { name: "dashboard-id", type: "number", required: false, desc: "Dashboard ID for a single-dashboard update." },
+    { name: "dashboard-ids", type: "json", required: false, desc: "Dashboard ID array for batch settings updates." },
+    { name: "dashboard-name", type: "string", required: false, desc: "Dashboard name for single rename." },
+    { name: "zone-offset", type: "number", required: false, desc: "Fixed dashboard time zone offset in hours. For example, UTC+8 is 8 and UTC-5 is -5. Valid range: -12 to 14." },
+    { name: "refresh-type", type: "number", required: false, desc: "Dashboard refresh type: 0 real-time, 1 scheduled.", min: 0, max: 1 },
+    { name: "dashboard-status", type: "string", required: false, desc: "Dashboard status: normal or freeze." },
+    { name: "note-id", type: "number", required: false, desc: "Dashboard note ID. Omit to create a new note." },
+    { name: "note-title", type: "string", required: false, desc: "Dashboard note title." },
+    { name: "description", type: "string", required: false, desc: "Dashboard note description." },
+    { name: "ui-config", type: "string", required: false, desc: "Dashboard or note UI config string." },
+    payloadFlag
+  ],
+  risk: "write",
+  buildInput: (ctx) => compactInput({
+    ...projectInput(ctx),
+    operation: ctx.str("operation"),
+    dashboard_id: optionalNumber2(ctx, "dashboard-id"),
+    dashboard_ids: optionalJsonArray(ctx, "dashboard-ids"),
+    dashboard_name: optionalString2(ctx, "dashboard-name"),
+    zone_offset: optionalNumber2(ctx, "zone-offset"),
+    refresh_type: optionalNumber2(ctx, "refresh-type"),
+    dashboard_status: optionalString2(ctx, "dashboard-status"),
+    note_id: optionalNumber2(ctx, "note-id"),
+    note_title: optionalString2(ctx, "note-title"),
+    description: optionalString2(ctx, "description"),
+    ui_config: optionalString2(ctx, "ui-config"),
+    payload: optionalJson(ctx, "payload")
+  })
+});
+
+// src/commands/te-analysis/dashboard/share-info.ts
+var dashboardShareInfo = createAnalysisCapabilityCommand({
+  resource: "dashboard",
+  command: "share-info",
+  capabilityId: "analysis.dashboard.share_info",
+  description: "Get dashboard sharing information.",
+  flags: [projectIdFlag, { name: "dashboard-id", type: "number", required: true, desc: "Dashboard ID." }],
+  risk: "read",
+  buildInput: (ctx) => ({
+    ...projectInput(ctx),
+    dashboard_id: ctx.num("dashboard-id")
+  })
+});
+
+// src/commands/te-analysis/dashboard/share.ts
+var dashboardShare = createAnalysisCapabilityCommand({
+  resource: "dashboard",
+  command: "share",
+  capabilityId: "analysis.dashboard.share",
+  description: "Modify dashboard sharing members through the capability gateway.",
+  flags: [
+    projectIdFlag,
+    { name: "dashboard-id", type: "number", required: true, desc: "Dashboard ID." },
+    { name: "member-authorities", type: "json", required: false, desc: 'Complete user authority map: {"<numeric_user_id>":"READ|EDIT|CREATOR|MAINTAIN"}. An empty object removes all directly shared users.' },
+    payloadFlag
+  ],
+  risk: "write",
+  buildInput: (ctx) => compactInput({
+    ...projectInput(ctx),
+    dashboard_id: ctx.num("dashboard-id"),
+    member_authorities: optionalJson(ctx, "member-authorities"),
+    payload: optionalJson(ctx, "payload")
+  })
+});
+
+// src/commands/te-analysis/dashboard/delete.ts
+var dashboardDelete = createAnalysisCapabilityCommand({
+  resource: "dashboard",
+  command: "delete",
+  capabilityId: "analysis.dashboard.delete",
+  description: "Delete one or more dashboards.",
+  flags: [projectIdFlag, { name: "dashboard-ids", type: "json", required: true, desc: "Dashboard ID array." }],
+  risk: "high-risk-write",
+  buildInput: (ctx) => ({
+    ...projectInput(ctx),
+    dashboard_ids: jsonArray(ctx, "dashboard-ids")
+  })
+});
+
+// src/commands/te-analysis/dashboard/handover.ts
+var dashboardHandover = createAnalysisCapabilityCommand({
+  resource: "dashboard",
+  command: "handover",
+  capabilityId: "analysis.dashboard.handover",
+  description: "Handover one or more dashboards to another project user.",
+  flags: [
+    projectIdFlag,
+    { name: "dashboard-ids", type: "json", required: true, desc: "Dashboard ID array." },
+    { name: "to-user-id", type: "number", required: true, desc: "Target user ID." }
+  ],
+  risk: "write",
+  buildInput: (ctx) => ({
+    ...projectInput(ctx),
+    dashboard_ids: jsonArray(ctx, "dashboard-ids"),
+    to_user_id: ctx.num("to-user-id")
+  })
+});
+
+// src/commands/te-analysis/dashboard/copy.ts
+var dashboardCopy = createAnalysisCapabilityCommand({
+  resource: "dashboard",
+  command: "copy",
+  capabilityId: "analysis.dashboard.copy",
+  description: "Copy a dashboard, optionally copying reports and targeting a project space or folder.",
+  flags: [
+    projectIdFlag,
+    { name: "dashboard-id", type: "number", required: true, desc: "Source dashboard ID." },
+    { name: "dashboard-name", type: "string", required: true, desc: "New dashboard name." },
+    { name: "report-copy", type: "boolean", required: false, desc: "Whether to copy reports. Default: false." },
+    { name: "to-space-id", type: "number", required: false, desc: "Target project space ID. If both target IDs are omitted, copy to the source dashboard location." },
+    { name: "to-folder-id", type: "number", required: false, desc: "Target folder ID. If both target IDs are omitted, copy to the source dashboard location." }
+  ],
+  risk: "write",
+  buildInput: (ctx) => compactInput({
+    ...projectInput(ctx),
+    dashboard_id: ctx.num("dashboard-id"),
+    dashboard_name: ctx.str("dashboard-name"),
+    report_copy: booleanWithDefault(ctx, "report-copy", false),
+    to_space_id: optionalNumber2(ctx, "to-space-id"),
+    to_folder_id: optionalNumber2(ctx, "to-folder-id")
+  })
+});
+
+// src/commands/te-analysis/dashboard/freeze.ts
+var dashboardFreeze = createAnalysisCapabilityCommand({
+  resource: "dashboard",
+  command: "freeze",
+  capabilityId: "analysis.dashboard.freeze",
+  description: "Freeze or unfreeze one or more dashboards.",
+  flags: [
+    projectIdFlag,
+    { name: "dashboard-ids", type: "json", required: true, desc: "Dashboard ID array." },
+    { name: "freeze", type: "boolean", required: false, desc: "true to freeze, false to unfreeze. Default: true." }
+  ],
+  risk: "write",
+  buildInput: (ctx) => compactInput({
+    ...projectInput(ctx),
+    dashboard_ids: jsonArray(ctx, "dashboard-ids"),
+    freeze: optionalBoolean2(ctx, "freeze")
+  })
+});
+
+// src/commands/te-analysis/dashboard/abnormal-get.ts
+var dashboardAbnormalGet = createAnalysisCapabilityCommand({
+  resource: "dashboard",
+  command: "abnormal-get",
+  capabilityId: "analysis.dashboard.abnormal_get",
+  description: "Get abnormal dependency information for a dashboard.",
+  flags: [projectIdFlag, { name: "dashboard-id", type: "number", required: true, desc: "Dashboard ID." }],
+  risk: "read",
+  buildInput: (ctx) => ({
+    ...projectInput(ctx),
+    dashboard_id: ctx.num("dashboard-id")
+  })
+});
+
+// src/commands/te-analysis/dashboard/task-status.ts
+var dashboardTaskStatus = createAnalysisCapabilityCommand({
+  resource: "dashboard",
+  command: "task-status",
+  capabilityId: "analysis.dashboard.task_status",
+  description: "Get dashboard scheduled task status.",
+  flags: [projectIdFlag, { name: "dashboard-id", type: "number", required: true, desc: "Dashboard ID." }],
+  risk: "read",
+  buildInput: (ctx) => ({
+    ...projectInput(ctx),
+    dashboard_id: ctx.num("dashboard-id")
+  })
+});
+
+// src/commands/te-analysis/dashboard/index.ts
+var commands17 = [
+  dashboardList,
+  dashboardCreate,
+  dashboardGet,
+  dashboardUpdate,
+  dashboardShareInfo,
+  dashboardShare,
+  dashboardDelete,
+  dashboardHandover,
+  dashboardCopy,
+  dashboardFreeze,
+  dashboardAbnormalGet,
+  dashboardTaskStatus
+];
+var dashboard_default = commands17;
+
+// src/commands/te-analysis/dashboard-report/add.ts
+var dashboardReportAdd = createAnalysisCapabilityCommand({
+  resource: "dashboard-report",
+  command: "add",
+  capabilityId: "analysis.dashboard_report.add",
+  description: "Add existing analysis reports to a dashboard.",
+  flags: [
+    projectIdFlag,
+    { name: "dashboard-id", type: "number", required: true, desc: "Dashboard ID." },
+    { name: "report-ids", type: "json", required: true, desc: "Report ID array to add." }
+  ],
+  risk: "write",
+  buildInput: (ctx) => ({
+    ...projectInput(ctx),
+    dashboard_id: ctx.num("dashboard-id"),
+    report_ids: jsonArray(ctx, "report-ids")
+  })
+});
+
+// src/commands/te-analysis/dashboard-report/index.ts
+var commands18 = [
+  dashboardReportAdd
+];
+var dashboard_report_default = commands18;
+
+// src/commands/te-analysis/dashboard-report-data/run.ts
+var dashboardReportDataRun = createAnalysisCapabilityCommand({
+  resource: "dashboard-report-data",
+  command: "run",
+  capabilityId: "analysis.dashboard_report_data.run",
+  description: `Run a bounded dashboard report data query. Filters and time overrides do not apply to SQL reports; data still returns with data.warnings listing SQL report_ids and ignored_fields. ${analysisDataRunRoutingHelp}`,
+  flags: [
+    projectIdFlag,
+    { name: "dashboard-id", type: "number", required: true, desc: "Dashboard ID." },
+    { name: "report-ids", type: "json", required: false, desc: "Optional report ID array. Omit to query all dashboard reports." },
+    { name: "filters", type: "json", required: false, desc: "Optional AI-facing filter {relation,items:[{field:{name,type?},operator,values?}]}. SQL reports ignore it and produce data.warnings; raw taFilters/junctionKind/filts are rejected." },
+    { name: "start-time", type: "string", required: false, desc: "Optional start date/time. SQL reports ignore it and produce data.warnings." },
+    { name: "end-time", type: "string", required: false, desc: "Optional end date/time. SQL reports ignore it and produce data.warnings." },
+    { name: "use-cache", type: "boolean", required: false, desc: "Whether to use cache. Default: true." },
+    { name: "request-id", type: "string", required: false, desc: "Optional cli_<32 lowercase hex> request ID. Generated when omitted." },
+    dashboardSyncTimeoutSecondsFlag,
+    syncLimitFlag
+  ],
+  risk: "read",
+  buildInput: dashboardReportDataInput,
+  postProcess: applyAnalysisInlineLimit
+});
+
+// src/commands/te-analysis/dashboard-report-data/export.ts
+var dashboardReportDataExport = createAnalysisCapabilityCommand({
+  resource: "dashboard-report-data",
+  command: "export",
+  capabilityId: "analysis.dashboard_report_data.export",
+  description: `Submit dashboard report data as an asynchronous gzip JSONL artifact. Filters and time overrides do not apply to SQL reports; the artifact still contains data plus structured warnings. The submit response and artifact metadata line contain query_context_id when Redis context creation succeeds. ${analysisDataExportRoutingHelp}`,
+  flags: [
+    projectIdFlag,
+    { name: "dashboard-id", type: "number", required: true, desc: "Dashboard ID." },
+    { name: "report-ids", type: "json", required: false, desc: "Optional report ID array. Omit to query all dashboard reports." },
+    { name: "filters", type: "json", required: false, desc: "Optional AI-facing filter {relation,items:[{field:{name,type?},operator,values?}]}. SQL reports ignore it and the artifact includes warnings; raw taFilters/junctionKind/filts are rejected." },
+    { name: "start-time", type: "string", required: false, desc: "Optional start date/time. SQL reports ignore it and the artifact includes warnings." },
+    { name: "end-time", type: "string", required: false, desc: "Optional end date/time. SQL reports ignore it and the artifact includes warnings." },
+    { name: "use-cache", type: "boolean", required: false, desc: "Whether to use cache. Default: true." },
+    { name: "request-id", type: "string", required: false, desc: "Optional cli_<32 lowercase hex> request ID. Generated when omitted." },
+    asyncTimeoutSecondsFlag,
+    { name: "artifact-format", type: "string", required: false, desc: "Artifact format. Only jsonl is supported." }
+  ],
+  risk: "read",
+  buildInput: dashboardReportDataInput
+});
+
+// src/commands/te-analysis/dashboard-report-data/index.ts
+var commands19 = [
+  dashboardReportDataRun,
+  dashboardReportDataExport
+];
+var dashboard_report_data_default = commands19;
+
+// src/commands/te-analysis/query/cancel.ts
+var queryCancel = createAnalysisCapabilityCommand({
+  resource: "query",
+  command: "cancel",
+  capabilityId: "analysis.query.cancel",
+  description: "Cancel an analysis capability-gateway query/export by run_id.",
+  flags: [
+    { name: "run-id", type: "string", required: true, desc: "Async run ID returned by an export capability." },
+    { name: "reason", type: "string", required: false, desc: "Optional cancellation reason." }
+  ],
+  risk: "write",
+  buildInput: (ctx) => compactInput({
+    run_id: ctx.str("run-id"),
+    reason: optionalString2(ctx, "reason")
+  })
+});
+
+// src/commands/te-analysis/query/shared.ts
+var targetFlag = {
+  name: "target",
+  type: "json",
+  required: true,
+  desc: "Use only when the upstream availability flag is true. Pass sources[].target_contract.default_target directly, or copy it and replace only named machine fields for a specific result; never infer from display text or raw QP."
+};
+var propertiesFlag = {
+  name: "properties",
+  type: "json",
+  required: false,
+  desc: "Optional backend property request object array. Omit for defaults; do not pass string-name arrays."
+};
+var useCacheFlag = {
+  name: "use-cache",
+  type: "boolean",
+  required: false,
+  desc: "Whether to use query cache. Default: true."
+};
+function createResultClusterInput(ctx) {
+  return compactInput({
+    query_context_id: ctx.str("query-context-id"),
+    target: ctx.json("target"),
+    cluster_name: ctx.str("cluster-name"),
+    display_name: optionalString2(ctx, "display-name"),
+    zone_offset: optionalNumber2(ctx, "zone-offset"),
+    request_id: optionalString2(ctx, "request-id"),
+    timeout_seconds: optionalNumber2(ctx, "timeout-seconds")
+  });
+}
+
+// src/commands/te-analysis/query/create-result-cluster.ts
+var queryCreateResultCluster = createAnalysisCapabilityCommand({
+  resource: "query",
+  command: "create-result-cluster",
+  capabilityId: "analysis.query.create_result_cluster",
+  description: "Create a reusable result cluster from users matched by a target in a previous analysis data query context. Works after adhoc, report-data, and dashboard-report-data run/export. Do not pass raw QP.",
+  flags: [
+    { name: "query-context-id", type: "string", required: true, desc: "query_context_id returned by an analysis data run/export." },
+    targetFlag,
+    { name: "cluster-name", type: "string", required: true, desc: "Unique result cluster name. Use letters, digits, and underscores." },
+    { name: "display-name", type: "string", required: false, desc: "Optional result cluster display name." },
+    { name: "zone-offset", type: "number", required: false, desc: "Optional timezone offset. UTC+8 is 8; UTC-5 is -5." },
+    requestIdFlag,
+    timeoutSecondsFlag
+  ],
+  risk: "write",
+  buildInput: createResultClusterInput
+});
+
+// src/commands/te-analysis/query/index.ts
+var commands20 = [
+  queryCancel,
+  queryCreateResultCluster
+];
+var query_default = commands20;
+
+// src/commands/te-analysis/run/inspect.ts
+var runInspect = {
+  service: "analysis",
+  resource: "run",
+  command: "inspect",
+  description: "Inspect an analysis capability-gateway async run by run_id. Use after adhoc/report-data/dashboard/BI export returns run_id.",
+  flags: [
+    { name: "run-id", type: "string", required: true, desc: "Async run ID returned by an export capability." }
+  ],
+  risk: "read",
+  dryRun: (ctx) => ({
+    method: "GET",
+    url: buildCapabilityGatewayUrl(
+      ctx.host(),
+      resolveGatewayDomain("analysis"),
+      `runs/${encodeURIComponent(ctx.str("run-id"))}`
+    )
+  }),
+  execute: async (ctx) => {
+    const result = await requestCapabilityGatewayWithEnvelope(
+      ctx.host(),
+      resolveGatewayDomain("analysis"),
+      `runs/${encodeURIComponent(ctx.str("run-id"))}`
+    );
+    return withOutputMetadata(result.data, result.meta);
+  }
+};
+
+// src/commands/te-analysis/run/index.ts
+var commands21 = [
+  runInspect
+];
+var run_default = commands21;
+
+// src/commands/te-analysis/artifact/download.ts
+import { mkdir, writeFile } from "fs/promises";
+import { dirname, resolve } from "path";
+function artifactPath(runId, artifactId) {
+  return `runs/${encodeURIComponent(runId)}/artifacts/${encodeURIComponent(artifactId)}/download`;
+}
+var artifactDownload = {
+  service: "analysis",
+  resource: "artifact",
+  command: "download",
+  description: "Download an analysis capability-gateway artifact by run_id and artifact_id. Keep run_id bound to artifact_id from the export result.",
+  flags: [
+    { name: "run-id", type: "string", required: true, desc: "Async run ID returned by an export capability." },
+    { name: "artifact-id", type: "string", required: true, desc: "Artifact ID returned by the same export capability." },
+    { name: "output", type: "string", required: true, desc: "Local output file path. Use a file path, not a directory." }
+  ],
+  risk: "read",
+  dryRun: (ctx) => ({
+    method: "GET",
+    url: buildCapabilityGatewayUrl(
+      ctx.host(),
+      resolveGatewayDomain("analysis"),
+      artifactPath(ctx.str("run-id"), ctx.str("artifact-id"))
+    ),
+    output_path: resolve(ctx.str("output"))
+  }),
+  execute: async (ctx) => {
+    const runId = ctx.str("run-id");
+    const artifactId = ctx.str("artifact-id");
+    const outputPath = resolve(ctx.str("output"));
+    await ensureArtifactReady(ctx.host(), runId, artifactId);
+    const resp = await fetchArtifact(ctx.host(), runId, artifactId);
+    const bytes = Buffer.from(await resp.arrayBuffer());
+    await mkdir(dirname(outputPath), { recursive: true });
+    await writeFile(outputPath, bytes);
+    return {
+      run_id: runId,
+      artifact_id: artifactId,
+      output_path: outputPath,
+      bytes: bytes.length,
+      content_type: resp.headers.get("content-type") ?? void 0,
+      content_encoding: resp.headers.get("content-encoding") ?? void 0,
+      content_disposition: resp.headers.get("content-disposition") ?? void 0
+    };
+  }
+};
+async function ensureArtifactReady(host, runId, artifactId) {
+  const descriptor = await inspectRun(host, runId);
+  if (descriptor.artifact_id && descriptor.artifact_id !== artifactId) {
+    throw new CapabilityGatewayError(
+      `artifact_id ${artifactId} does not belong to run_id ${runId}`,
+      "ARTIFACT_RUN_MISMATCH",
+      400,
+      "Use the run_id and artifact_id pair from the same export response."
+    );
+  }
+  if (descriptor.status === "SUCCEEDED" && descriptor.artifact_status === "COMPLETED") {
+    return;
+  }
+  const reason = descriptor.error_message ? `; error=${descriptor.error_message}` : "";
+  throw new CapabilityGatewayError(
+    `Artifact is not ready: run_status=${descriptor.status ?? "UNKNOWN"}, artifact_status=${descriptor.artifact_status ?? "UNKNOWN"}${reason}`,
+    "ARTIFACT_NOT_READY",
+    409,
+    "Run ae-cli analysis run inspect --run-id <run_id> until status=SUCCEEDED and artifact_status=COMPLETED, then retry artifact download. If status is FAILED or CANCELED, do not retry download."
+  );
+}
+async function inspectRun(host, runId) {
+  return await requestCapabilityGateway(
+    host,
+    resolveGatewayDomain("analysis"),
+    `runs/${encodeURIComponent(runId)}`
+  );
+}
+async function fetchArtifact(host, runId, artifactId) {
+  return fetchCapabilityGateway(
+    host,
+    resolveGatewayDomain("analysis"),
+    artifactPath(runId, artifactId),
+    "GET",
+    void 0,
+    "application/octet-stream"
+  );
+}
+
+// src/commands/te-analysis/artifact/index.ts
+var commands22 = [
+  artifactDownload
+];
+var artifact_default = commands22;
+
+// src/commands/te-analysis/adhoc/shared.ts
+var useCacheFlag2 = {
+  name: "use-cache",
+  type: "boolean",
+  required: false,
+  desc: "Whether to use query cache. Default: true."
+};
+var zoneOffsetFlag2 = {
+  name: "zone-offset",
+  type: "number",
+  required: false,
+  desc: "Optional timezone offset. UTC+8 is 8; UTC-5 is -5."
+};
+function adhocRunInput(ctx) {
+  return compactInput({
+    project_id: ctx.num("project-id"),
+    model_type: ctx.str("model-type"),
+    definition: ctx.json("definition"),
+    request_id: optionalString2(ctx, "request-id"),
+    use_cache: optionalBoolean2(ctx, "use-cache"),
+    zone_offset: optionalNumber2(ctx, "zone-offset"),
+    fields: optionalJsonArray(ctx, "fields"),
+    limit: optionalNumber2(ctx, "limit"),
+    timeout_seconds: optionalNumber2(ctx, "timeout-seconds")
+  });
+}
+function adhocExportInput(ctx) {
+  return compactInput({
+    project_id: ctx.num("project-id"),
+    model_type: ctx.str("model-type"),
+    definition: ctx.json("definition"),
+    request_id: optionalString2(ctx, "request-id"),
+    use_cache: optionalBoolean2(ctx, "use-cache"),
+    zone_offset: optionalNumber2(ctx, "zone-offset"),
+    fields: optionalJsonArray(ctx, "fields"),
+    format: optionalString2(ctx, "artifact-format"),
+    timeout_seconds: optionalNumber2(ctx, "timeout-seconds")
+  });
+}
+var adhocBaseFlags = [
+  projectIdFlag,
+  aiModelTypeFlag(true),
+  aiDefinitionFlag(true),
+  requestIdFlag,
+  useCacheFlag2,
+  zoneOffsetFlag2,
+  fieldsFlag
+];
+var adhocExportFlags = [
+  ...adhocBaseFlags,
+  artifactFormatFlag,
+  asyncTimeoutSecondsFlag
+];
+
+// src/commands/te-analysis/adhoc/run.ts
+var adhocRun = createAnalysisCapabilityCommand({
+  resource: "adhoc",
+  command: "run",
+  capabilityId: "analysis.adhoc.run",
+  description: `Run one unified ad-hoc analysis from an AI-facing model definition. Supports 12 AI-facing models: 9 common models plus 3 scenario models. Tags and cohorts/clusters are separate capabilities, not ad-hoc model_type values. Returns query_context_id for Redis-backed query follow-ups. ${analysisDataRunRoutingHelp}`,
+  flags: [
+    ...adhocBaseFlags,
+    syncLimitFlag,
+    syncTimeoutSecondsFlag
+  ],
+  risk: "read",
+  buildInput: adhocRunInput,
+  postProcess: applyAnalysisInlineLimit
+});
+
+// src/commands/te-analysis/adhoc/export.ts
+var adhocExport = createAnalysisCapabilityCommand({
+  resource: "adhoc",
+  command: "export",
+  capabilityId: "analysis.adhoc.export",
+  description: `Submit one unified ad-hoc analysis export from an AI-facing model definition. Returns run_id/artifact_id plus the actual format, compression, file_name, content_type, and content_encoding; the artifact-format flag selects logical rows, not compression. The submit response and artifact metadata line contain query_context_id when Redis context creation succeeds. ${analysisDataExportRoutingHelp}`,
+  flags: [
+    ...adhocExportFlags
+  ],
+  risk: "read",
+  buildInput: adhocExportInput
+});
+
+// src/commands/te-analysis/adhoc/index.ts
+var commands23 = [
+  adhocRun,
+  adhocExport
+];
+var adhoc_default = commands23;
+
+// src/commands/te-analysis/dashboard-definition/export.ts
+var dashboardDefinitionExport = createAnalysisCapabilityCommand({
+  resource: "dashboard-definition",
+  command: "export",
+  capabilityId: "analysis.dashboard_definition.export",
+  description: "Export dashboard definition JSON.",
+  flags: [
+    projectIdFlag,
+    { name: "dashboard-id", type: "number", required: false, desc: "Single dashboard ID to export. The gateway resolves folder or project-space context." },
+    { name: "dashboard-ids", type: "json", required: false, desc: "Dashboard ID array to export. The gateway resolves folder or project-space context." },
+    { name: "dashboard-folder-ids", type: "json", required: false, desc: 'Private folder ID array, or advanced descriptor array: [{"dashboard_folder_id":1,"dashboard_ids":[2]}].' },
+    { name: "shared-spaces", type: "json", required: false, desc: "Shared space export descriptor array." },
+    { name: "export-file-name", type: "string", required: false, desc: "Optional export file name." },
+    payloadFlag
+  ],
+  risk: "read",
+  buildInput: (ctx) => compactInput({
+    ...projectInput(ctx),
+    dashboard_id: optionalNumber2(ctx, "dashboard-id"),
+    dashboard_ids: optionalJsonArray(ctx, "dashboard-ids"),
+    dashboard_folder_ids: optionalJsonArray(ctx, "dashboard-folder-ids"),
+    shared_spaces: optionalJson(ctx, "shared-spaces"),
+    export_file_name: optionalString2(ctx, "export-file-name"),
+    payload: optionalJson(ctx, "payload")
+  })
+});
+
+// src/commands/te-analysis/dashboard-definition/import.ts
+var dashboardDefinitionImport = createAnalysisCapabilityCommand({
+  resource: "dashboard-definition",
+  command: "import",
+  capabilityId: "analysis.dashboard_definition.import",
+  description: "Validate or import dashboard definition JSON. Use --validate-only for import pre-check.",
+  flags: [
+    projectIdFlag,
+    { name: "definition", type: "json", required: true, desc: "Dashboard definition JSON object." },
+    { name: "validate-only", type: "boolean", required: false, desc: "Only validate import conflicts and importable state." },
+    { name: "dashboard-name-conflict-policy", type: "string", required: false, desc: "Optional dashboard name conflict policy." },
+    { name: "space-dashboard-policy", type: "string", required: false, desc: "Optional space/dashboard import policy." },
+    payloadFlag
+  ],
+  risk: "write",
+  buildInput: (ctx) => compactInput({
+    ...projectInput(ctx),
+    definition: ctx.json("definition"),
+    validate_only: optionalBoolean2(ctx, "validate-only"),
+    dashboard_name_conflict_policy: optionalString2(ctx, "dashboard-name-conflict-policy"),
+    space_dashboard_policy: optionalString2(ctx, "space-dashboard-policy"),
+    payload: optionalJson(ctx, "payload")
+  })
+});
+
+// src/commands/te-analysis/dashboard-definition/index.ts
+var commands24 = [
+  dashboardDefinitionExport,
+  dashboardDefinitionImport
+];
+var dashboard_definition_default = commands24;
+
+// src/commands/te-analysis/dashboard-daily-report/shared.ts
+function dailyReportFlags(update) {
+  const falseDefault = update ? " Default: false." : "";
+  const emptyDefault = update ? " Default: empty." : "";
+  const weekdayDefault = update ? " Default: 1,2,3,4,5,6,7." : "";
+  const timeDefault = update ? " Default: 09:00." : "";
+  const langDefault = update ? " Default: zh-CN." : "";
+  const screenDefault = update ? " Default: normal." : "";
+  const zoneDefault = update ? " Default: 0." : "";
+  return [
+    { name: "need-csv", type: "boolean", required: false, desc: `Whether to include CSV attachment.${falseDefault}` },
+    { name: "host-url", type: "string", required: false, desc: `Public host URL used in report links.${emptyDefault}` },
+    { name: "enable-smtp", type: "boolean", required: false, desc: `Whether to use configured SMTP for email.${falseDefault}` },
+    { name: "enable-email", type: "boolean", required: false, desc: `Whether to send by email.${falseDefault}` },
+    { name: "enable-dd", type: "boolean", required: false, desc: `Whether to send by DingTalk webhook.${falseDefault}` },
+    { name: "dd-url", type: "json", required: false, desc: 'DingTalk webhook URL array, e.g. ["https://..."].' },
+    { name: "enable-wx", type: "boolean", required: false, desc: `Whether to send by WeCom webhook.${falseDefault}` },
+    { name: "wx-url", type: "json", required: false, desc: 'WeCom webhook URL array, e.g. ["https://..."].' },
+    { name: "enable-feishu", type: "boolean", required: false, desc: `Whether to send by Feishu webhook.${falseDefault}` },
+    { name: "feishu-info", type: "json", required: false, desc: 'Feishu config object, e.g. {"webhook":["https://..."]}.' },
+    { name: "enable-kim", type: "boolean", required: false, desc: `Whether to send by KIM/custom webhook.${falseDefault}` },
+    { name: "kim-url", type: "json", required: false, desc: 'KIM/custom webhook URL array, e.g. ["https://..."].' },
+    { name: "enable-slack", type: "boolean", required: false, desc: `Whether to send by Slack webhook.${falseDefault}` },
+    { name: "slack-url", type: "json", required: false, desc: 'Slack webhook URL array, e.g. ["https://..."].' },
+    { name: "email-login-users", type: "string", required: false, desc: "Comma-separated login users for email channel." },
+    { name: "email-new", type: "string", required: false, desc: "Comma-separated external emails when SMTP is enabled." },
+    { name: "send-title", type: "string", required: false, desc: "Daily report title." },
+    { name: "send-content", type: "string", required: false, desc: "Daily report content." },
+    { name: "send-date", type: "string", required: false, desc: `Scheduled weekdays, comma-separated 1..7.${weekdayDefault}` },
+    { name: "send-time", type: "string", required: false, desc: `Scheduled send time, HH:mm.${timeDefault}` },
+    { name: "lang", type: "string", required: false, desc: `Report language.${langDefault}` },
+    { name: "screen-type", type: "string", required: false, desc: `Screenshot screen type.${screenDefault}` },
+    { name: "zone-offset", type: "number", required: false, desc: `Time zone offset.${zoneDefault}` },
+    ...update ? [
+      { name: "enable-send", type: "boolean", required: false, desc: "Whether to enable scheduled sending. Default: false." }
+    ] : []
+  ];
+}
+function dailyReportInput(ctx, update) {
+  const payload = optionalJson(ctx, "payload");
+  const useDefaults = update && payload === void 0;
+  return compactInput({
+    ...projectInput(ctx),
+    dashboard_id: ctx.num("dashboard-id"),
+    need_csv: useDefaults ? booleanWithDefault(ctx, "need-csv", false) : optionalBoolean2(ctx, "need-csv"),
+    host_url: useDefaults ? stringWithDefault(ctx, "host-url", "") : optionalString2(ctx, "host-url"),
+    enable_smtp: useDefaults ? booleanWithDefault(ctx, "enable-smtp", false) : optionalBoolean2(ctx, "enable-smtp"),
+    enable_email: useDefaults ? booleanWithDefault(ctx, "enable-email", false) : optionalBoolean2(ctx, "enable-email"),
+    enable_dd: useDefaults ? booleanWithDefault(ctx, "enable-dd", false) : optionalBoolean2(ctx, "enable-dd"),
+    dd_url: optionalJson(ctx, "dd-url"),
+    enable_wx: useDefaults ? booleanWithDefault(ctx, "enable-wx", false) : optionalBoolean2(ctx, "enable-wx"),
+    wx_url: optionalJson(ctx, "wx-url"),
+    enable_feishu: useDefaults ? booleanWithDefault(ctx, "enable-feishu", false) : optionalBoolean2(ctx, "enable-feishu"),
+    feishu_info: optionalJson(ctx, "feishu-info"),
+    enable_kim: useDefaults ? booleanWithDefault(ctx, "enable-kim", false) : optionalBoolean2(ctx, "enable-kim"),
+    kim_url: optionalJson(ctx, "kim-url"),
+    enable_slack: useDefaults ? booleanWithDefault(ctx, "enable-slack", false) : optionalBoolean2(ctx, "enable-slack"),
+    slack_url: optionalJson(ctx, "slack-url"),
+    email_login_users: optionalString2(ctx, "email-login-users"),
+    email_new: optionalString2(ctx, "email-new"),
+    send_title: optionalString2(ctx, "send-title"),
+    send_content: optionalString2(ctx, "send-content"),
+    send_date: useDefaults ? stringWithDefault(ctx, "send-date", "1,2,3,4,5,6,7") : optionalString2(ctx, "send-date"),
+    send_time: useDefaults ? stringWithDefault(ctx, "send-time", "09:00") : optionalString2(ctx, "send-time"),
+    lang: useDefaults ? stringWithDefault(ctx, "lang", "zh-CN") : optionalString2(ctx, "lang"),
+    screen_type: useDefaults ? stringWithDefault(ctx, "screen-type", "normal") : optionalString2(ctx, "screen-type"),
+    zone_offset: useDefaults ? numberWithDefault(ctx, "zone-offset", 0) : optionalNumber2(ctx, "zone-offset"),
+    enable_send: update ? useDefaults ? booleanWithDefault(ctx, "enable-send", false) : optionalBoolean2(ctx, "enable-send") : void 0,
+    payload
+  });
+}
+
+// src/commands/te-analysis/dashboard-daily-report/update.ts
+var dashboardDailyReportUpdate = createAnalysisCapabilityCommand({
+  resource: "dashboard-daily-report",
+  command: "update",
+  capabilityId: "analysis.dashboard_daily_report.update",
+  description: "Update dashboard daily report configuration.",
+  flags: [
+    projectIdFlag,
+    { name: "dashboard-id", type: "number", required: true, desc: "Dashboard ID." },
+    ...dailyReportFlags(true),
+    payloadFlag
+  ],
+  risk: "write",
+  buildInput: (ctx) => dailyReportInput(ctx, true)
+});
+
+// src/commands/te-analysis/dashboard-daily-report/send.ts
+var dashboardDailyReportSend = createAnalysisCapabilityCommand({
+  resource: "dashboard-daily-report",
+  command: "send",
+  capabilityId: "analysis.dashboard_daily_report.send",
+  description: "Send dashboard daily report immediately. Omit config to use saved config; pass channel flags for an ad hoc send.",
+  flags: [
+    projectIdFlag,
+    { name: "dashboard-id", type: "number", required: true, desc: "Dashboard ID." },
+    ...dailyReportFlags(false),
+    payloadFlag
+  ],
+  risk: "write",
+  buildInput: (ctx) => dailyReportInput(ctx, false)
+});
+
+// src/commands/te-analysis/dashboard-daily-report/index.ts
+var commands25 = [
+  dashboardDailyReportUpdate,
+  dashboardDailyReportSend
+];
+var dashboard_daily_report_default = commands25;
+
+// src/commands/te-analysis/bi-panel/list.ts
+var biPanelList = createAnalysisCapabilityCommand({
+  resource: "bi-panel",
+  command: "list",
+  capabilityId: "analysis.bi_panel.list",
+  description: "List BI panels visible to the current user through the capability gateway.",
+  flags: [projectIdFlag, queryFlag, fieldsFlag, directoryLimitFlag, offsetFlag],
+  risk: "read",
+  buildInput: listInput
+});
+
+// src/commands/te-analysis/bi-panel/get.ts
+var biPanelGet = createAnalysisCapabilityCommand({
+  resource: "bi-panel",
+  command: "get",
+  capabilityId: "analysis.bi_panel.get",
+  description: "Get a BI panel released page structure. Use bi-panel-version get --version-type draft for unpublished edits.",
+  flags: [
+    projectIdFlag,
+    { name: "panel-id", type: "number", required: true, desc: "BI panel ID." },
+    fieldsFlag
+  ],
+  risk: "read",
+  buildInput: (ctx) => compactInput({
+    ...projectInput(ctx),
+    panel_id: ctx.num("panel-id"),
+    fields: optionalJson(ctx, "fields")
+  })
+});
+
+// src/commands/te-analysis/bi-panel/create.ts
+var biPanelCreate = createAnalysisCapabilityCommand({
+  resource: "bi-panel",
+  command: "create",
+  capabilityId: "analysis.bi_panel.create",
+  description: "Create a BI panel.",
+  flags: [
+    projectIdFlag,
+    { name: "panel-name", type: "string", required: false, desc: "BI panel name." },
+    { name: "panel-uuid", type: "string", required: false, desc: "BI panel UUID." },
+    { name: "space-id", type: "number", required: false, desc: "Target project space ID." },
+    { name: "folder-id", type: "number", required: false, desc: "Target folder ID." },
+    payloadFlag
+  ],
+  risk: "write",
+  buildInput: (ctx) => compactInput({
+    ...projectInput(ctx),
+    panel_name: optionalString2(ctx, "panel-name"),
+    panel_uuid: optionalString2(ctx, "panel-uuid"),
+    space_id: optionalNumber2(ctx, "space-id"),
+    folder_id: optionalNumber2(ctx, "folder-id"),
+    payload: optionalJson(ctx, "payload")
+  })
+});
+
+// src/commands/te-analysis/bi-panel/update.ts
+var biPanelUpdate = createAnalysisCapabilityCommand({
+  resource: "bi-panel",
+  command: "update",
+  capabilityId: "analysis.bi_panel.update",
+  description: "Update BI panel content or metadata.",
+  flags: [
+    projectIdFlag,
+    { name: "panel-name", type: "string", required: false, desc: "BI panel name." },
+    { name: "panel-uuid", type: "string", required: false, desc: "BI panel UUID." },
+    payloadFlag
+  ],
+  risk: "write",
+  buildInput: (ctx) => compactInput({
+    ...projectInput(ctx),
+    panel_name: optionalString2(ctx, "panel-name"),
+    panel_uuid: optionalString2(ctx, "panel-uuid"),
+    payload: optionalJson(ctx, "payload")
+  })
+});
+
+// src/commands/te-analysis/bi-panel/delete.ts
+var biPanelDelete = createAnalysisCapabilityCommand({
+  resource: "bi-panel",
+  command: "delete",
+  capabilityId: "analysis.bi_panel.delete",
+  description: "Delete one or more BI panels.",
+  flags: [projectIdFlag, { name: "panel-ids", type: "json", required: true, desc: "BI panel ID array." }],
+  risk: "high-risk-write",
+  buildInput: (ctx) => ({
+    ...projectInput(ctx),
+    panel_ids: jsonArray(ctx, "panel-ids")
+  })
+});
+
+// src/commands/te-analysis/bi-panel/share.ts
+var biPanelShare = createAnalysisCapabilityCommand({
+  resource: "bi-panel",
+  command: "share",
+  capabilityId: "analysis.bi_panel.share",
+  description: "Modify BI panel sharing members.",
+  flags: [projectIdFlag, { name: "panel-id", type: "number", required: true, desc: "BI panel ID." }, payloadFlag],
+  risk: "write",
+  buildInput: (ctx) => compactInput({
+    ...projectInput(ctx),
+    panel_id: ctx.num("panel-id"),
+    payload: optionalJson(ctx, "payload")
+  })
+});
+
+// src/commands/te-analysis/bi-panel/copy.ts
+var biPanelCopy = createAnalysisCapabilityCommand({
+  resource: "bi-panel",
+  command: "copy",
+  capabilityId: "analysis.bi_panel.copy",
+  description: "Copy a BI panel.",
+  flags: [
+    projectIdFlag,
+    { name: "panel-name", type: "string", required: false, desc: "New BI panel name." },
+    { name: "panel-uuid", type: "string", required: false, desc: "Source BI panel UUID." },
+    { name: "space-id", type: "number", required: false, desc: "Target project space ID." },
+    { name: "folder-id", type: "number", required: false, desc: "Target folder ID." },
+    payloadFlag
+  ],
+  risk: "write",
+  buildInput: (ctx) => compactInput({
+    ...projectInput(ctx),
+    panel_name: optionalString2(ctx, "panel-name"),
+    panel_uuid: optionalString2(ctx, "panel-uuid"),
+    space_id: optionalNumber2(ctx, "space-id"),
+    folder_id: optionalNumber2(ctx, "folder-id"),
+    payload: optionalJson(ctx, "payload")
+  })
+});
+
+// src/commands/te-analysis/bi-panel/index.ts
+var commands26 = [
+  biPanelList,
+  biPanelGet,
+  biPanelCreate,
+  biPanelUpdate,
+  biPanelDelete,
+  biPanelShare,
+  biPanelCopy
+];
+var bi_panel_default = commands26;
+
+// src/commands/te-analysis/bi-panel-version/get.ts
+var biPanelVersionGet = createAnalysisCapabilityCommand({
+  resource: "bi-panel-version",
+  command: "get",
+  capabilityId: "analysis.bi_panel_version.get",
+  description: "Get a BI panel release or draft version. Use draft to inspect unpublished edits.",
+  flags: [
+    projectIdFlag,
+    { name: "panel-id", type: "number", required: false, desc: "BI panel ID. Required when --panel-uuid is omitted." },
+    { name: "panel-uuid", type: "string", required: false, desc: "BI panel UUID. Required when --panel-id is omitted." },
+    { name: "version-type", type: "string", required: false, desc: "Version to inspect: release or draft. Default: release." },
+    fieldsFlag
+  ],
+  risk: "read",
+  buildInput: (ctx) => compactInput({
+    ...projectInput(ctx),
+    panel_id: ctx.str("panel-id") === "" ? void 0 : ctx.num("panel-id"),
+    panel_uuid: optionalString2(ctx, "panel-uuid"),
+    version_type: optionalString2(ctx, "version-type"),
+    fields: optionalJson(ctx, "fields")
+  })
+});
+
+// src/commands/te-analysis/bi-panel-version/publish.ts
+var biPanelVersionPublish = createAnalysisCapabilityCommand({
+  resource: "bi-panel-version",
+  command: "publish",
+  capabilityId: "analysis.bi_panel_version.publish",
+  description: "Publish the current BI panel draft. Requires source version returned by bi-panel-version get.",
+  flags: [
+    projectIdFlag,
+    { name: "panel-id", type: "number", required: false, desc: "BI panel ID. Required when --panel-uuid is omitted." },
+    { name: "panel-uuid", type: "string", required: false, desc: "BI panel UUID. Required when --panel-id is omitted." },
+    { name: "source-version", type: "string", required: true, desc: "Current draft version to publish, for example 0.1." }
+  ],
+  risk: "write",
+  buildInput: (ctx) => compactInput({
+    ...projectInput(ctx),
+    panel_id: ctx.str("panel-id") === "" ? void 0 : ctx.num("panel-id"),
+    panel_uuid: optionalString2(ctx, "panel-uuid"),
+    source_version: ctx.str("source-version")
+  })
+});
+
+// src/commands/te-analysis/bi-panel-version/index.ts
+var commands27 = [
+  biPanelVersionGet,
+  biPanelVersionPublish
+];
+var bi_panel_version_default = commands27;
+
+// src/commands/te-analysis/bi-panel-page-data/run.ts
+var biPanelPageDataRun = createAnalysisCapabilityCommand({
+  resource: "bi-panel-page-data",
+  command: "run",
+  capabilityId: "analysis.bi_panel_page_data.run",
+  description: `Run a bounded BI panel page data query and return inline JSON. Chart results may include query_context_id; BI SQL chart contexts are not model-drilldown contexts unless drilldown_available=true. ${analysisDataRunRoutingHelp}`,
+  flags: [
+    projectIdFlag,
+    { name: "panel-id", type: "number", required: true, desc: "BI panel ID." },
+    { name: "page-key", type: "string", required: true, desc: "Page key returned by bi-panel get." },
+    { name: "result-type", type: "string", required: true, desc: "Result type: charts or summary." },
+    { name: "chart-ids", type: "json", required: false, desc: "Optional chart ID array." },
+    { name: "parameter-controls", type: "json", required: false, desc: "Optional parameter control override array." },
+    { name: "permission-controls", type: "json", required: false, desc: "Optional permission control array." },
+    { name: "chart-filter-controls", type: "json", required: false, desc: "Optional chart filter control array." },
+    { name: "columns", type: "json", required: false, desc: "Optional returned column array." },
+    { name: "row-limit", type: "number", required: false, desc: "BI chart row window control. Default: 100, max: 1000. This is chart paging, not the sync/export routing policy.", min: 1, max: 1e3 },
+    { name: "row-offset", type: "number", required: false, desc: "Chart row offset." },
+    { name: "block-limit", type: "number", required: false, desc: "Summary block limit." },
+    { name: "block-offset", type: "number", required: false, desc: "Summary block offset." },
+    { name: "use-cache", type: "boolean", required: false, desc: "Whether to use cache. Default: true." },
+    { name: "request-id", type: "string", required: false, desc: "Optional cli_<32 lowercase hex> request ID. Generated when omitted." },
+    syncTimeoutSecondsFlag,
+    syncLimitFlag
+  ],
+  risk: "read",
+  buildInput: biPanelPageDataInput,
+  postProcess: applyAnalysisInlineLimit
+});
+
+// src/commands/te-analysis/bi-panel-page-data/export.ts
+var biPanelPageDataExport = createAnalysisCapabilityCommand({
+  resource: "bi-panel-page-data",
+  command: "export",
+  capabilityId: "analysis.bi_panel_page_data.export",
+  description: `Submit a BI panel page data query as an asynchronous gzip JSONL artifact. Chart exports may include query_context_id metadata; BI SQL chart contexts are not model-drilldown contexts unless drilldown_available=true. ${analysisDataExportRoutingHelp}`,
+  flags: [
+    projectIdFlag,
+    { name: "panel-id", type: "number", required: true, desc: "BI panel ID." },
+    { name: "page-key", type: "string", required: true, desc: "Page key returned by bi-panel get." },
+    { name: "result-type", type: "string", required: true, desc: "Result type: charts or summary." },
+    { name: "chart-ids", type: "json", required: false, desc: "Optional chart ID array." },
+    { name: "parameter-controls", type: "json", required: false, desc: "Optional parameter control override array." },
+    { name: "permission-controls", type: "json", required: false, desc: "Optional permission control array." },
+    { name: "chart-filter-controls", type: "json", required: false, desc: "Optional chart filter control array." },
+    { name: "columns", type: "json", required: false, desc: "Optional returned column array." },
+    { name: "row-limit", type: "number", required: false, desc: "BI chart row window control. Default: 100, max: 1000. This is chart paging, not the async artifact total-row policy.", min: 1, max: 1e3 },
+    { name: "row-offset", type: "number", required: false, desc: "Chart row offset." },
+    { name: "block-limit", type: "number", required: false, desc: "Summary block limit." },
+    { name: "block-offset", type: "number", required: false, desc: "Summary block offset." },
+    { name: "use-cache", type: "boolean", required: false, desc: "Whether to use cache. Default: true." },
+    { name: "request-id", type: "string", required: false, desc: "Optional cli_<32 lowercase hex> request ID. Generated when omitted." },
+    asyncTimeoutSecondsFlag,
+    { name: "artifact-format", type: "string", required: false, desc: "Artifact format. Only jsonl is supported." }
+  ],
+  risk: "read",
+  buildInput: biPanelPageDataInput
+});
+
+// src/commands/te-analysis/bi-panel-page-data/index.ts
+var commands28 = [
+  biPanelPageDataRun,
+  biPanelPageDataExport
+];
+var bi_panel_page_data_default = commands28;
+
+// src/commands/te-analysis/project-space/list.ts
+var projectSpaceList = createAnalysisCapabilityCommand({
+  resource: "project-space",
+  command: "list",
+  capabilityId: "analysis.project_space.list",
+  description: "List project spaces visible to the current user.",
+  flags: [projectIdFlag, queryFlag, fieldsFlag, directoryLimitFlag, offsetFlag],
+  risk: "read",
+  buildInput: listInput
+});
+
+// src/commands/te-analysis/project-space/get.ts
+var projectSpaceGet = createAnalysisCapabilityCommand({
+  resource: "project-space",
+  command: "get",
+  capabilityId: "analysis.project_space.get",
+  description: "Get one project space detail.",
+  flags: [projectIdFlag, { name: "space-id", type: "number", required: true, desc: "Project space ID." }, fieldsFlag],
+  risk: "read",
+  buildInput: (ctx) => compactInput({
+    ...projectInput(ctx),
+    space_id: ctx.num("space-id"),
+    fields: optionalJson(ctx, "fields")
+  })
+});
+
+// src/commands/te-analysis/project-space/index.ts
+var commands29 = [
+  projectSpaceList,
+  projectSpaceGet
+];
+var project_space_default = commands29;
+
+// src/commands/te-analysis/favorite/add.ts
+var favoriteAdd = createAnalysisCapabilityCommand({
+  resource: "favorite",
+  command: "add",
+  capabilityId: "analysis.favorite.add",
+  description: "Favorite one dashboard, BI panel, or folder.",
+  flags: [
+    projectIdFlag,
+    { name: "asset-id", type: "number", required: false, desc: "Asset ID." },
+    { name: "asset-type", type: "string", required: false, desc: "Asset type, for example dashboard, bi_panel, or folder." },
+    { name: "space-id", type: "number", required: false, desc: "Project space ID when relevant." },
+    { name: "id", type: "number", required: false, desc: "Backend DTO ID field when required." },
+    payloadFlag
+  ],
+  risk: "write",
+  buildInput: (ctx) => compactInput({
+    ...projectInput(ctx),
+    asset_id: optionalNumber2(ctx, "asset-id"),
+    asset_type: optionalString2(ctx, "asset-type"),
+    space_id: optionalNumber2(ctx, "space-id"),
+    id: optionalNumber2(ctx, "id"),
+    payload: optionalJson(ctx, "payload")
+  })
+});
+
+// src/commands/te-analysis/favorite/remove.ts
+var favoriteRemove = createAnalysisCapabilityCommand({
+  resource: "favorite",
+  command: "remove",
+  capabilityId: "analysis.favorite.remove",
+  description: "Remove favorite from one dashboard, BI panel, or folder.",
+  flags: [
+    projectIdFlag,
+    { name: "asset-id", type: "number", required: false, desc: "Asset ID." },
+    { name: "asset-type", type: "string", required: false, desc: "Asset type, for example dashboard, bi_panel, or folder." },
+    { name: "space-id", type: "number", required: false, desc: "Project space ID when relevant." },
+    { name: "id", type: "number", required: false, desc: "Backend DTO ID field when required." },
+    payloadFlag
+  ],
+  risk: "write",
+  buildInput: (ctx) => compactInput({
+    ...projectInput(ctx),
+    asset_id: optionalNumber2(ctx, "asset-id"),
+    asset_type: optionalString2(ctx, "asset-type"),
+    space_id: optionalNumber2(ctx, "space-id"),
+    id: optionalNumber2(ctx, "id"),
+    payload: optionalJson(ctx, "payload")
+  })
+});
+
+// src/commands/te-analysis/favorite/index.ts
+var commands30 = [
+  favoriteAdd,
+  favoriteRemove
+];
+var favorite_default = commands30;
+
+// src/commands/te-analysis/public-link/create.ts
+var publicLinkCreate = createAnalysisCapabilityCommand({
+  resource: "public-link",
+  command: "create",
+  capabilityId: "analysis.public_link.create",
+  description: "Create a public link for a dashboard or BI panel.",
+  flags: [
+    projectIdFlag,
+    { name: "company-id", type: "number", required: false, desc: "Company ID. Derived from project ID when omitted." },
+    { name: "resource-type", type: "string", required: true, desc: "Resource type: dashboard or bi_panel." },
+    { name: "resource-id", type: "number", required: true, desc: "Target resource ID." },
+    { name: "access-controls", type: "json", required: false, desc: "Public link access-control JSON." },
+    { name: "remark", type: "string", required: false, desc: "Public link remark." },
+    { name: "effective-at", type: "string", required: true, desc: "Effective time, yyyy-MM-dd HH:mm:ss." },
+    { name: "expires-at", type: "string", required: true, desc: "Expiration time, yyyy-MM-dd HH:mm:ss." },
+    payloadFlag
+  ],
+  risk: "write",
+  buildInput: (ctx) => compactInput({
+    ...projectInput(ctx),
+    company_id: optionalNumber2(ctx, "company-id"),
+    resource_type: ctx.str("resource-type"),
+    resource_id: ctx.num("resource-id"),
+    access_controls: optionalJson(ctx, "access-controls"),
+    remark: optionalString2(ctx, "remark"),
+    effective_at: ctx.str("effective-at"),
+    expires_at: ctx.str("expires-at"),
+    payload: optionalJson(ctx, "payload")
+  })
+});
+
+// src/commands/te-analysis/public-link/list.ts
+var publicLinkList = createAnalysisCapabilityCommand({
+  resource: "public-link",
+  command: "list",
+  capabilityId: "analysis.public_link.list",
+  description: "List public links in a project.",
+  flags: [projectIdFlag, queryFlag, fieldsFlag, directoryLimitFlag, offsetFlag],
+  risk: "read",
+  buildInput: listInput
+});
+
+// src/commands/te-analysis/public-link/update.ts
+var publicLinkUpdate = createAnalysisCapabilityCommand({
+  resource: "public-link",
+  command: "update",
+  capabilityId: "analysis.public_link.update",
+  description: "Update a public link.",
+  flags: [
+    projectIdFlag,
+    { name: "company-id", type: "number", required: false, desc: "Company ID. Derived from project ID when omitted." },
+    { name: "link-id", type: "number", required: true, desc: "Public link ID." },
+    { name: "access-controls", type: "json", required: false, desc: "Public link access-control JSON." },
+    { name: "remark", type: "string", required: false, desc: "Public link remark." },
+    { name: "effective-at", type: "string", required: true, desc: "Effective time, yyyy-MM-dd HH:mm:ss." },
+    { name: "expires-at", type: "string", required: true, desc: "Expiration time, yyyy-MM-dd HH:mm:ss." },
+    payloadFlag
+  ],
+  risk: "write",
+  buildInput: (ctx) => compactInput({
+    ...projectInput(ctx),
+    company_id: optionalNumber2(ctx, "company-id"),
+    link_id: ctx.num("link-id"),
+    access_controls: optionalJson(ctx, "access-controls"),
+    remark: optionalString2(ctx, "remark"),
+    effective_at: ctx.str("effective-at"),
+    expires_at: ctx.str("expires-at"),
+    payload: optionalJson(ctx, "payload")
+  })
+});
+
+// src/commands/te-analysis/public-link/offline.ts
+var publicLinkOffline = createAnalysisCapabilityCommand({
+  resource: "public-link",
+  command: "offline",
+  capabilityId: "analysis.public_link.offline",
+  description: "Offline one or more public links.",
+  flags: [
+    projectIdFlag,
+    { name: "company-id", type: "number", required: false, desc: "Company ID. Derived from project ID when omitted." },
+    { name: "link-id", type: "number", required: false, desc: "Public link ID." },
+    { name: "link-ids", type: "json", required: false, desc: "Public link ID array." }
+  ],
+  risk: "write",
+  buildInput: (ctx) => compactInput({
+    ...projectInput(ctx),
+    company_id: optionalNumber2(ctx, "company-id"),
+    link_id: optionalNumber2(ctx, "link-id"),
+    link_ids: optionalJsonArray(ctx, "link-ids")
+  })
+});
+
+// src/commands/te-analysis/public-link/delete.ts
+var publicLinkDelete = createAnalysisCapabilityCommand({
+  resource: "public-link",
+  command: "delete",
+  capabilityId: "analysis.public_link.delete",
+  description: "Delete one or more public links.",
+  flags: [
+    projectIdFlag,
+    { name: "company-id", type: "number", required: false, desc: "Company ID. Derived from project ID when omitted." },
+    { name: "link-id", type: "number", required: false, desc: "Public link ID." },
+    { name: "link-ids", type: "json", required: false, desc: "Public link ID array." }
+  ],
+  risk: "high-risk-write",
+  buildInput: (ctx) => compactInput({
+    ...projectInput(ctx),
+    company_id: optionalNumber2(ctx, "company-id"),
+    link_id: optionalNumber2(ctx, "link-id"),
+    link_ids: optionalJsonArray(ctx, "link-ids")
+  })
+});
+
+// src/commands/te-analysis/public-link/index.ts
+var commands31 = [
+  publicLinkCreate,
+  publicLinkList,
+  publicLinkUpdate,
+  publicLinkOffline,
+  publicLinkDelete
+];
+var public_link_default = commands31;
+
+// src/commands/te-analysis/model/cancel-query.ts
+var cancelQuery = createMcpCommand({
+  command: "+cancel_query",
+  description: "Cancel a running MCP query by request ID. Use this when a previous query is no longer needed, the caller or agent timed out before the query returned, the request returns fetch failed, hits an HTTP timeout, or the user asks to stop waiting. If fetch failed, HTTP timeout, or caller timeout happens, the backend query may still be running; call +cancel_query --request_id <same value> with the requestId supplied before starting the query. For proactive cancellation, generate and pass requestId to the query tool before starting it, then call cancel_query with the same value if you stop waiting.",
+  flags: [
+    { name: "request_id", type: "string", required: true, desc: "Request ID returned by a query tool in metadata.requestId, or the requestId supplied before starting the query. It must use mcp_<32 lowercase hex UUID>, for example mcp_0123456789abcdef0123456789abcdef." },
+    { name: "reason", type: "string", required: false, desc: "Optional cancellation reason. Default: MCP_CANCEL_QUERY_TOOL." }
+  ],
+  risk: "write",
+  buildArgs: (ctx) => ({
+    requestId: ctx.str("request_id"),
+    reason: optionalString(ctx, "reason")
+  })
+});
+
+// src/commands/te-analysis/model/load-filters.ts
+var loadFilters = createMcpCommand({
+  command: "+load_filters",
+  description: "Load candidate values for a property from event or user tables. Use quot to specify the property field whose enum values should be loaded.",
+  flags: [
+    { name: "project_id", type: "number", required: true, alias: "p", desc: "Project ID" },
+    { name: "quot", type: "string", required: true, desc: "Property identifier (field name). This is the property whose candidate values will be loaded." },
+    { name: "table_type", type: "string", required: true, desc: "Table type. Supported values: event and user." },
+    { name: "event_name", type: "string", required: false, desc: "Optional event name. Effective when table_type=event." },
+    { name: "inputdata", type: "string", required: false, desc: "Optional input prefix used for fuzzy filtering of candidate values." },
+    { name: "zone_offset", type: "number", required: false, desc: "Time zone offset in hours. For example, UTC+8 is 8" },
+    { name: "cluster_date_policy", type: "string", required: false, desc: "Cluster date policy. Supported values: LATEST, AUTO, SPECIFIED." },
+    { name: "specified_cluster_date", type: "string", required: false, desc: "Specified cluster date in yyyy-MM-dd format. Effective only when cluster_date_policy=SPECIFIED." },
+    { name: "is_report", type: "boolean", required: false, desc: "Whether this is report mode. Default: false" }
+  ],
+  risk: "read",
+  mcpService: "te_analysis_extend",
+  buildArgs: (ctx) => ({
+    projectId: ctx.num("project_id"),
+    quot: ctx.str("quot"),
+    tableType: ctx.str("table_type"),
+    eventName: optionalString(ctx, "event_name"),
+    inputdata: optionalString(ctx, "inputdata"),
+    zoneOffset: optionalNumber(ctx, "zone_offset"),
+    clusterDatePolicy: optionalString(ctx, "cluster_date_policy"),
+    specifiedClusterDate: optionalString(ctx, "specified_cluster_date"),
+    isReport: optionalBoolean(ctx, "is_report")
+  })
+});
+
+// src/commands/te-analysis/model/index.ts
+var commands32 = [
+  cancelQuery,
+  loadFilters
+];
+var model_default = commands32;
+
+// src/commands/te-analysis/event-detail/shared.ts
+var eventDetailDefinitionFlag = {
+  name: "definition",
+  type: "json",
+  required: true,
+  desc: 'AI-facing event detail definition: {"event":"login","time_range":{"mode":"absolute","start_time":"2026-07-01 00:00:00","end_time":"2026-07-01 23:59:59"},"filters":{"relation":"and","items":[{"field":{"name":"country","type":"user_property"},"operator":"eq","values":["US"]}]},"properties":["#event_time",{"name":"country","type":"user_property"}],"sort":[{"field":"#event_time","order":"desc"}]}. Do not pass raw QP/eventView/taFilters.'
+};
+function eventDetailRunInput(ctx) {
+  return compactInput({
+    project_id: ctx.num("project-id"),
+    definition: ctx.json("definition"),
+    request_id: optionalString2(ctx, "request-id"),
+    use_cache: optionalBoolean2(ctx, "use-cache"),
+    zone_offset: optionalNumber2(ctx, "zone-offset"),
+    limit: optionalNumber2(ctx, "limit"),
+    timeout_seconds: optionalNumber2(ctx, "timeout-seconds")
+  });
+}
+function eventDetailExportInput(ctx) {
+  return compactInput({
+    project_id: ctx.num("project-id"),
+    definition: ctx.json("definition"),
+    request_id: optionalString2(ctx, "request-id"),
+    use_cache: optionalBoolean2(ctx, "use-cache"),
+    zone_offset: optionalNumber2(ctx, "zone-offset"),
+    format: optionalString2(ctx, "artifact-format"),
+    timeout_seconds: optionalNumber2(ctx, "timeout-seconds")
+  });
+}
+var eventDetailBaseFlags = [
+  projectIdFlag,
+  eventDetailDefinitionFlag,
+  requestIdFlag,
+  useCacheFlag2,
+  zoneOffsetFlag2
+];
+var eventDetailExportFlags = [
+  ...eventDetailBaseFlags,
+  artifactFormatFlag,
+  asyncTimeoutSecondsFlag
+];
+
+// src/commands/te-analysis/event-detail/run.ts
+var eventDetailRun = createAnalysisCapabilityCommand({
+  resource: "event-detail",
+  command: "run",
+  capabilityId: "analysis.event_detail.run",
+  description: `Run a bounded event detail query from an AI-facing definition. ${analysisDataRunRoutingHelp}`,
+  flags: [
+    ...eventDetailBaseFlags,
+    detailPreviewLimitFlag,
+    syncTimeoutSecondsFlag
+  ],
+  risk: "read",
+  buildInput: eventDetailRunInput,
+  postProcess: applyAnalysisInlineLimit
+});
+
+// src/commands/te-analysis/event-detail/export.ts
+var eventDetailExport = createAnalysisCapabilityCommand({
+  resource: "event-detail",
+  command: "export",
+  capabilityId: "analysis.event_detail.export",
+  description: "Export complete event detail data as an asynchronous gzip artifact. The server reads backend pages internally; callers inspect and download one artifact without pagination.",
+  flags: [
+    ...eventDetailExportFlags
+  ],
+  risk: "read",
+  buildInput: eventDetailExportInput
+});
+
+// src/commands/te-analysis/event-detail/index.ts
+var commands33 = [
+  eventDetailRun,
+  eventDetailExport
+];
+var event_detail_default = commands33;
+
+// src/commands/te-analysis/entity-detail/shared.ts
+var entityDetailDefinitionFlag = {
+  name: "definition",
+  type: "json",
+  required: true,
+  desc: 'Bounded entity detail definition: {"entity":"user","cohort":{"relation":"and","items":[{"field":{"name":"level","type":"user_property"},"operator":"gte","values":[1]}]},"properties":["#user_id",{"name":"country","type":"user_property"}],"sort":[{"field":"#user_id","order":"asc"}]}. cohort is AI-facing for user_property/tag/cluster filters; do not pass raw QP at the capability top level.'
+};
+function entityDetailRunInput(ctx) {
+  return compactInput({
+    project_id: ctx.num("project-id"),
+    definition: ctx.json("definition"),
+    request_id: optionalString2(ctx, "request-id"),
+    use_cache: optionalBoolean2(ctx, "use-cache"),
+    zone_offset: optionalNumber2(ctx, "zone-offset"),
+    limit: optionalNumber2(ctx, "limit"),
+    timeout_seconds: optionalNumber2(ctx, "timeout-seconds")
+  });
+}
+function entityDetailExportInput(ctx) {
+  return compactInput({
+    project_id: ctx.num("project-id"),
+    definition: ctx.json("definition"),
+    request_id: optionalString2(ctx, "request-id"),
+    use_cache: optionalBoolean2(ctx, "use-cache"),
+    zone_offset: optionalNumber2(ctx, "zone-offset"),
+    format: optionalString2(ctx, "artifact-format"),
+    timeout_seconds: optionalNumber2(ctx, "timeout-seconds")
+  });
+}
+var entityDetailBaseFlags = [
+  projectIdFlag,
+  entityDetailDefinitionFlag,
+  requestIdFlag,
+  useCacheFlag2,
+  zoneOffsetFlag2
+];
+var entityDetailExportFlags = [
+  ...entityDetailBaseFlags,
+  artifactFormatFlag,
+  asyncTimeoutSecondsFlag
+];
+
+// src/commands/te-analysis/entity-detail/run.ts
+var entityDetailRun = createAnalysisCapabilityCommand({
+  resource: "entity-detail",
+  command: "run",
+  capabilityId: "analysis.entity_detail.run",
+  description: `Run a bounded entity detail query from a cluster cohort definition. ${analysisDataRunRoutingHelp}`,
+  flags: [
+    ...entityDetailBaseFlags,
+    detailPreviewLimitFlag,
+    syncTimeoutSecondsFlag
+  ],
+  risk: "read",
+  buildInput: entityDetailRunInput,
+  postProcess: applyAnalysisInlineLimit
+});
+
+// src/commands/te-analysis/entity-detail/export.ts
+var entityDetailExport = createAnalysisCapabilityCommand({
+  resource: "entity-detail",
+  command: "export",
+  capabilityId: "analysis.entity_detail.export",
+  description: "Export complete entity detail data as an asynchronous gzip artifact. The server reads backend pages internally; callers inspect and download one artifact without pagination.",
+  flags: [
+    ...entityDetailExportFlags
+  ],
+  risk: "read",
+  buildInput: entityDetailExportInput
+});
+
+// src/commands/te-analysis/entity-detail/index.ts
+var commands34 = [
+  entityDetailRun,
+  entityDetailExport
+];
+var entity_detail_default = commands34;
+
+// src/commands/te-analysis/drilldown-users/shared.ts
+var queryContextIdFlag = {
+  name: "query-context-id",
+  type: "string",
+  required: true,
+  desc: "query_context_id returned by an analysis data run/export."
+};
+var jsonlArtifactFormatFlag = {
+  name: "artifact-format",
+  type: "string",
+  required: false,
+  desc: "Artifact format. Only jsonl is supported."
+};
+var drilldownUsersBaseFlags = [
+  queryContextIdFlag,
+  targetFlag,
+  propertiesFlag,
+  requestIdFlag,
+  useCacheFlag
+];
+var drilldownUsersRunFlags = [
+  ...drilldownUsersBaseFlags,
+  detailPreviewLimitFlag,
+  syncTimeoutSecondsFlag
+];
+var drilldownUsersExportFlags = [
+  ...drilldownUsersBaseFlags,
+  jsonlArtifactFormatFlag,
+  asyncTimeoutSecondsFlag
+];
+function drilldownUsersRunInput(ctx) {
+  return compactInput({
+    ...baseInput(ctx),
+    limit: optionalNumber2(ctx, "limit"),
+    timeout_seconds: optionalNumber2(ctx, "timeout-seconds")
+  });
+}
+function drilldownUsersExportInput(ctx) {
+  return compactInput({
+    ...baseInput(ctx),
+    format: optionalString2(ctx, "artifact-format"),
+    timeout_seconds: optionalNumber2(ctx, "timeout-seconds")
+  });
+}
+function baseInput(ctx) {
+  return {
+    query_context_id: ctx.str("query-context-id"),
+    target: ctx.json("target"),
+    properties: optionalJson(ctx, "properties"),
+    request_id: optionalString2(ctx, "request-id"),
+    use_cache: optionalBoolean2(ctx, "use-cache")
+  };
+}
+
+// src/commands/te-analysis/drilldown-users/export.ts
+var drilldownUsersExport = createAnalysisCapabilityCommand({
+  resource: "drilldown-users",
+  command: "export",
+  capabilityId: "analysis.query.drilldown_users.export",
+  description: `Export users from a previous analysis query context as a jsonl artifact. ${analysisDataExportRoutingHelp}`,
+  flags: [...drilldownUsersExportFlags],
+  risk: "read",
+  buildInput: drilldownUsersExportInput
+});
+
+// src/commands/te-analysis/drilldown-users/run.ts
+var drilldownUsersRun = createAnalysisCapabilityCommand({
+  resource: "drilldown-users",
+  command: "run",
+  capabilityId: "analysis.query.drilldown_users",
+  description: `Preview users from a previous analysis query context. Do not pass raw QP. ${analysisDataRunRoutingHelp}`,
+  flags: [...drilldownUsersRunFlags],
+  risk: "read",
+  buildInput: drilldownUsersRunInput,
+  postProcess: applyAnalysisInlineLimit
+});
+
+// src/commands/te-analysis/drilldown-users/index.ts
+var commands35 = [drilldownUsersRun, drilldownUsersExport];
+var drilldown_users_default = commands35;
+
+// src/commands/te-analysis/drilldown-user-events/shared.ts
+var drilldownContextIdFlag = {
+  name: "drilldown-context-id",
+  type: "string",
+  required: true,
+  desc: "drilldown_context_id returned by analysis drilldown-users run."
+};
+var userIdFlag = {
+  name: "user-id",
+  type: "string",
+  required: true,
+  desc: "User ID returned by analysis drilldown-users run/export."
+};
+var sequenceFlags = [
+  propertiesFlag,
+  { name: "sort-order", type: "string", required: false, desc: "Event time sort order: asc or desc." },
+  { name: "event-name-filter", type: "string", required: false, desc: "Optional event-name filter." },
+  { name: "time-filter", type: "string", required: false, desc: "Optional time filter condition." },
+  { name: "time-filter-before-nums", type: "number", required: false, desc: "Optional events before the time filter point." },
+  { name: "time-filter-after-nums", type: "number", required: false, desc: "Optional events after the time filter point." }
+];
+var jsonlArtifactFormatFlag2 = {
+  name: "artifact-format",
+  type: "string",
+  required: false,
+  desc: "Artifact format. Only jsonl is supported."
+};
+var drilldownUserEventsBaseFlags = [
+  drilldownContextIdFlag,
+  userIdFlag,
+  ...sequenceFlags,
+  requestIdFlag,
+  useCacheFlag
+];
+var drilldownUserEventsRunFlags = [
+  ...drilldownUserEventsBaseFlags,
+  detailPreviewLimitFlag,
+  syncTimeoutSecondsFlag
+];
+var drilldownUserEventsExportFlags = [
+  ...drilldownUserEventsBaseFlags,
+  jsonlArtifactFormatFlag2,
+  asyncTimeoutSecondsFlag
+];
+function drilldownUserEventsRunInput(ctx) {
+  return compactInput({
+    ...baseInput2(ctx),
+    limit: optionalNumber2(ctx, "limit"),
+    timeout_seconds: optionalNumber2(ctx, "timeout-seconds")
+  });
+}
+function drilldownUserEventsExportInput(ctx) {
+  return compactInput({
+    ...baseInput2(ctx),
+    format: optionalString2(ctx, "artifact-format"),
+    timeout_seconds: optionalNumber2(ctx, "timeout-seconds")
+  });
+}
+function baseInput2(ctx) {
+  return {
+    drilldown_context_id: ctx.str("drilldown-context-id"),
+    user_id: ctx.str("user-id"),
+    properties: optionalJson(ctx, "properties"),
+    sort_order: optionalString2(ctx, "sort-order"),
+    event_name_filter: optionalString2(ctx, "event-name-filter"),
+    time_filter: optionalString2(ctx, "time-filter"),
+    time_filter_before_nums: optionalNumber2(ctx, "time-filter-before-nums"),
+    time_filter_after_nums: optionalNumber2(ctx, "time-filter-after-nums"),
+    request_id: optionalString2(ctx, "request-id"),
+    use_cache: optionalBoolean2(ctx, "use-cache")
+  };
+}
+
+// src/commands/te-analysis/drilldown-user-events/export.ts
+var drilldownUserEventsExport = createAnalysisCapabilityCommand({
+  resource: "drilldown-user-events",
+  command: "export",
+  capabilityId: "analysis.query.drilldown_user_events.export",
+  description: `Export one user's event sequence from a drilldown context as a jsonl artifact. ${analysisDataExportRoutingHelp}`,
+  flags: [...drilldownUserEventsExportFlags],
+  risk: "read",
+  buildInput: drilldownUserEventsExportInput
+});
+
+// src/commands/te-analysis/drilldown-user-events/run.ts
+var drilldownUserEventsRun = createAnalysisCapabilityCommand({
+  resource: "drilldown-user-events",
+  command: "run",
+  capabilityId: "analysis.query.drilldown_user_events",
+  description: `Preview one user's event sequence from a drilldown context. Do not pass raw QP. ${analysisDataRunRoutingHelp}`,
+  flags: [...drilldownUserEventsRunFlags],
+  risk: "read",
+  buildInput: drilldownUserEventsRunInput,
+  postProcess: applyAnalysisInlineLimit
+});
+
+// src/commands/te-analysis/drilldown-user-events/index.ts
+var commands36 = [drilldownUserEventsRun, drilldownUserEventsExport];
+var drilldown_user_events_default = commands36;
+
+// src/commands/te-analysis/user/index.ts
+import { existsSync, statSync } from "fs";
+var authenticatedOnlyFlag = {
+  name: "authenticated-only",
+  type: "boolean",
+  required: false,
+  desc: "Return only resources whose metadata can be resolved under the current identity."
+};
+var tagListFieldsFlag = {
+  ...fieldsFlag,
+  desc: "Optional tag inventory projection. Use tag_name, display_name, users_num, and other tag fields. cluster_name is reserved for user clusters and is rejected here."
+};
+var tagMemberFieldsFlag = {
+  ...fieldsFlag,
+  desc: "Optional result fields. Defaults to #user_id, #account_id, #distinct_id, and tag_value."
+};
+var clusterMemberFieldsFlag = {
+  ...fieldsFlag,
+  desc: "Optional result fields. Defaults to #user_id, #account_id, and #distinct_id."
+};
+var clusterNameFlag = {
+  name: "cluster-name",
+  type: "string",
+  required: true,
+  desc: "Exact cluster_name. Discover real values with analysis user-cluster list first."
+};
+var tagNameFlag = {
+  name: "tag-name",
+  type: "string",
+  required: true,
+  desc: "Exact tag_name. Discover real values with analysis user-tag list first."
+};
+var displayNameFlag = {
+  name: "display-name",
+  type: "string",
+  required: true,
+  desc: "Human-readable display name."
+};
+var optionalDisplayNameFlag = {
+  ...displayNameFlag,
+  required: false,
+  desc: "Optional new display name."
+};
+var clusterDefinitionRequestFlag = {
+  name: "definition-request",
+  type: "json",
+  required: true,
+  desc: "Semantic snake_case cluster definition. Read skills/ae-analysis/references/user_cluster_models.md; shared primitives are in audience_models.md."
+};
+var optionalClusterDefinitionRequestFlag = {
+  ...clusterDefinitionRequestFlag,
+  required: false,
+  desc: "Optional semantic snake_case cluster definition. Read user_cluster_models.md; raw filts, C-codes, ftv, columnName, and backend DTOs are rejected."
+};
+var tagDefinitionRequestFlag = {
+  ...clusterDefinitionRequestFlag,
+  desc: "Semantic snake_case tag definition. Read skills/ae-analysis/references/user_tag_models.md; shared primitives are in audience_models.md."
+};
+var optionalTagDefinitionRequestFlag = {
+  ...tagDefinitionRequestFlag,
+  required: false,
+  desc: "Optional semantic snake_case tag definition. Read user_tag_models.md; raw filts, C-codes, ftv, columnName, and backend DTOs are rejected."
+};
+var zoneOffsetFlag3 = {
+  name: "zone-offset",
+  type: "number",
+  required: false,
+  desc: "Optional timezone offset. UTC+8 is 8; UTC-5 is -5."
+};
+var entityIdFlag = {
+  name: "entity-id",
+  type: "number",
+  required: false,
+  desc: "Optional entity ID. Required by ID-file create commands."
+};
+var requiredEntityIdFlag = {
+  ...entityIdFlag,
+  required: true,
+  desc: "Required analysis entity. Use the primary user entity only when matching uploaded external identifiers through a user property."
+};
+var inputFileIdFlag = {
+  name: "input-file-id",
+  type: "string",
+  required: false,
+  desc: "Reuse a file already uploaded for purpose analysis.user.id_import."
+};
+var inputFileFlag = {
+  name: "input-file",
+  type: "string",
+  required: false,
+  desc: "Local CSV path. The CLI uploads it with purpose analysis.user.id_import before executing the create/update capability."
+};
+var clusterFileContentFlag = {
+  name: "file-content",
+  type: "string",
+  required: false,
+  desc: "Headerless UTF-8 CSV. No header row. Exactly one non-empty column per row: association-property value for the primary user entity, otherwise the entity ID."
+};
+var tagFileContentFlag = {
+  name: "file-content",
+  type: "string",
+  required: false,
+  desc: "Headerless UTF-8 CSV. No header row. Exactly two non-empty columns per row: association-property value or entity ID, then tag_value."
+};
+var associationPropertyFlag = {
+  name: "association-property",
+  type: "string",
+  required: false,
+  desc: "Required only for the primary user entity. The first CSV column is matched against this allowed user property; #user_id is forbidden. Omit for non-primary entities."
+};
+var remarksFlag = {
+  name: "remarks",
+  type: "string",
+  required: false,
+  desc: "Optional remarks."
+};
+var remarkFlag = {
+  name: "remark",
+  type: "string",
+  required: false,
+  desc: "Optional new remark."
+};
+var propertyNamesFlag = {
+  name: "property-names",
+  type: "json",
+  required: false,
+  desc: "Optional JSON array of user property names to include."
+};
+var snapshotDateFlag = {
+  name: "snapshot-date",
+  type: "string",
+  required: false,
+  desc: "Optional tag snapshot date, yyyy-MM-dd."
+};
+var jsonlArtifactFormatFlag3 = {
+  name: "artifact-format",
+  type: "string",
+  required: false,
+  desc: "Artifact format. Only jsonl is supported for user member/history-tag exports."
+};
+var confirmedFlag = {
+  name: "confirmed",
+  type: "boolean",
+  required: false,
+  desc: "Set true only after dependency and influence checks have been accepted."
+};
+var refreshDateFlag = {
+  name: "refresh-date",
+  type: "string",
+  required: true,
+  desc: "History tag date to refresh, yyyy-MM-dd."
+};
+var historyViewFlag = {
+  name: "view",
+  type: "json",
+  required: true,
+  desc: "AI-facing history tag view with interval_type/property_range/time_particle/array_group_type/column_splited_str."
+};
+var groupColFlag = {
+  name: "group-col",
+  type: "string",
+  required: true,
+  desc: "Exact statistic value or bucket from history-tag-data results to drill down into."
+};
+function capability(resource, command, capabilityId, description, flags, risk, buildInput) {
+  return createAnalysisCapabilityCommand({
+    resource,
+    command,
+    capabilityId,
+    description,
+    flags,
+    risk,
+    buildInput
+  });
+}
+function idImportCapability(command) {
+  const originalValidate = command.validate;
+  const originalValidateInput = command.validateInput;
+  const originalDryRun = command.dryRun;
+  const originalExecute = command.execute;
+  return {
+    ...command,
+    flags: command.flags.flatMap((flag) => flag.name === "input-file-id" ? [inputFileFlag, flag] : [flag]),
+    validate: (ctx) => {
+      originalValidate?.(ctx);
+      const sources = ["input-file", "input-file-id", "file-content"].filter((name) => ctx.str(name).trim() !== "");
+      if (sources.length !== 1) {
+        throw new Error("Pass exactly one of --input-file, --input-file-id, or --file-content");
+      }
+      const localFile = ctx.str("input-file");
+      if (localFile && (!existsSync(localFile) || !statSync(localFile).isFile())) {
+        throw new Error(`--input-file must reference a readable local file: ${localFile}`);
+      }
+    },
+    validateInput: originalValidateInput ? async (ctx) => ctx.str("input-file") ? {
+      valid: true,
+      validation_scope: "local_orchestration",
+      input_file: ctx.str("input-file"),
+      next_step: "Execution uploads this file with purpose analysis.user.id_import, then validates and executes the capability with the returned input_file_id."
+    } : originalValidateInput(ctx) : void 0,
+    dryRun: originalDryRun ? async (ctx) => {
+      if (!ctx.str("input-file")) {
+        return originalDryRun(ctx);
+      }
+      return {
+        steps: [
+          {
+            method: "POST",
+            url: buildCapabilityGatewayUrl(ctx.host(), resolveGatewayDomain("analysis"), "input-files"),
+            body: { multipart: { project_id: ctx.num("project-id"), purpose: "analysis.user.id_import", file: ctx.str("input-file") } }
+          },
+          {
+            method: "POST",
+            url: `${ctx.host()}/api/cli/${resolveGatewayDomain("analysis")}/v1/capabilities/${command.capabilityId}/dry-run`,
+            body: {
+              input_file_id: "<input_file_id returned by upload step>",
+              note: "The remaining command flags are sent unchanged after upload."
+            }
+          }
+        ]
+      };
+    } : void 0,
+    execute: async (ctx) => {
+      if (!ctx.str("input-file")) {
+        return originalExecute(ctx);
+      }
+      const uploaded = await uploadInputFile(
+        ctx.host(),
+        resolveGatewayDomain("analysis"),
+        ctx.num("project-id"),
+        "analysis.user.id_import",
+        ctx.str("input-file")
+      );
+      const inputFileId = uploadedInputFileId(uploaded);
+      return originalExecute(withInputFileId(ctx, inputFileId));
+    }
+  };
+}
+function withInputFileId(ctx, inputFileId) {
+  if (!inputFileId) return ctx;
+  return new Proxy(ctx, {
+    get(target, property, receiver) {
+      if (property === "str") {
+        return (name) => name === "input-file-id" ? inputFileId : target.str(name);
+      }
+      return Reflect.get(target, property, target);
+    }
+  });
+}
+function uploadedInputFileId(value) {
+  const inputFileId = value?.input_file_id ?? value?.inputFileId ?? value?.data?.input_file_id ?? value?.data?.inputFileId;
+  if (typeof inputFileId !== "string" || !inputFileId.startsWith("ifile_")) {
+    throw new Error("Analysis input-file upload did not return input_file_id");
+  }
+  return inputFileId;
+}
+function assetListInput(ctx) {
+  return compactInput({
+    project_id: ctx.num("project-id"),
+    query: optionalString2(ctx, "query"),
+    fields: optionalJsonArray(ctx, "fields"),
+    limit: optionalNumber2(ctx, "limit"),
+    offset: optionalNumber2(ctx, "offset"),
+    authenticated_only: optionalBoolean2(ctx, "authenticated-only")
+  });
+}
+function memberInput(ctx, kind, inline) {
+  return compactInput({
+    project_id: ctx.num("project-id"),
+    cluster_name: kind === "cluster" ? ctx.str("cluster-name") : void 0,
+    tag_name: kind === "tag" ? ctx.str("tag-name") : void 0,
+    snapshot_date: kind === "tag" ? optionalString2(ctx, "snapshot-date") : void 0,
+    property_names: optionalJsonArray(ctx, "property-names"),
+    fields: optionalJsonArray(ctx, "fields"),
+    query: optionalString2(ctx, "query"),
+    use_cache: optionalBoolean2(ctx, "use-cache"),
+    request_id: optionalString2(ctx, "request-id"),
+    timeout_seconds: optionalNumber2(ctx, "timeout-seconds"),
+    limit: inline ? optionalNumber2(ctx, "limit") : void 0,
+    format: inline ? void 0 : optionalJsonlFormat(ctx)
+  });
+}
+function clusterWriteInput(ctx, create) {
+  const definitionRequest = optionalJson(ctx, "definition-request");
+  validateDefinitionRequest(create, definitionRequest);
+  return compactInput({
+    project_id: ctx.num("project-id"),
+    cluster_name: ctx.str("cluster-name"),
+    display_name: create ? ctx.str("display-name") : optionalString2(ctx, "display-name"),
+    definition_request: definitionRequest,
+    authenticated_only: optionalBoolean2(ctx, "authenticated-only"),
+    remark: create ? void 0 : optionalString2(ctx, "remark"),
+    zone_offset: optionalNumber2(ctx, "zone-offset"),
+    entity_id: create ? optionalNumber2(ctx, "entity-id") : void 0
+  });
+}
+function tagWriteInput(ctx, create) {
+  const definitionRequest = optionalJson(ctx, "definition-request");
+  validateDefinitionRequest(create, definitionRequest);
+  return compactInput({
+    project_id: ctx.num("project-id"),
+    tag_name: ctx.str("tag-name"),
+    display_name: create ? ctx.str("display-name") : optionalString2(ctx, "display-name"),
+    definition_request: definitionRequest,
+    authenticated_only: optionalBoolean2(ctx, "authenticated-only"),
+    remark: create ? void 0 : optionalString2(ctx, "remark"),
+    zone_offset: optionalNumber2(ctx, "zone-offset"),
+    entity_id: create ? optionalNumber2(ctx, "entity-id") : void 0
+  });
+}
+function validateDefinitionRequest(create, definitionRequest) {
+  if (create && definitionRequest === void 0) {
+    throw new Error("Pass --definition-request");
+  }
+}
+function idClusterInput(ctx, create) {
+  return compactInput({
+    project_id: ctx.num("project-id"),
+    cluster_name: create ? optionalString2(ctx, "cluster-name") : ctx.str("cluster-name"),
+    display_name: create ? ctx.str("display-name") : optionalString2(ctx, "display-name"),
+    input_file_id: optionalString2(ctx, "input-file-id"),
+    file_content: optionalString2(ctx, "file-content"),
+    entity_id: create ? ctx.num("entity-id") : void 0,
+    remarks: optionalString2(ctx, "remarks"),
+    main_column_name: optionalString2(ctx, "association-property")
+  });
+}
+function idTagInput(ctx, create) {
+  return compactInput({
+    project_id: ctx.num("project-id"),
+    tag_name: create ? optionalString2(ctx, "tag-name") : ctx.str("tag-name"),
+    display_name: create ? ctx.str("display-name") : optionalString2(ctx, "display-name"),
+    input_file_id: optionalString2(ctx, "input-file-id"),
+    file_content: optionalString2(ctx, "file-content"),
+    entity_id: create ? ctx.num("entity-id") : optionalNumber2(ctx, "entity-id"),
+    remarks: optionalString2(ctx, "remarks"),
+    main_column_name: optionalString2(ctx, "association-property")
+  });
+}
+function historyTagDataInput(ctx, inline) {
+  return compactInput({
+    project_id: ctx.num("project-id"),
+    tag_name: ctx.str("tag-name"),
+    view: ctx.json("view"),
+    request_id: optionalString2(ctx, "request-id"),
+    timeout_seconds: optionalNumber2(ctx, "timeout-seconds"),
+    limit: inline ? optionalNumber2(ctx, "limit") : void 0,
+    format: inline ? void 0 : optionalJsonlFormat(ctx)
+  });
+}
+function historyTagDataDrilldownInput(ctx, inline) {
+  return compactInput({
+    project_id: ctx.num("project-id"),
+    tag_name: ctx.str("tag-name"),
+    snapshot_date: ctx.str("snapshot-date"),
+    group_col: ctx.str("group-col"),
+    view: ctx.json("view"),
+    property_names: optionalJsonArray(ctx, "property-names"),
+    fields: optionalJsonArray(ctx, "fields"),
+    query: optionalString2(ctx, "query"),
+    use_cache: optionalBoolean2(ctx, "use-cache"),
+    request_id: optionalString2(ctx, "request-id"),
+    timeout_seconds: optionalNumber2(ctx, "timeout-seconds"),
+    limit: inline ? optionalNumber2(ctx, "limit") : void 0,
+    format: inline ? void 0 : optionalJsonlFormat(ctx)
+  });
+}
+function optionalJsonlFormat(ctx) {
+  const format = optionalString2(ctx, "artifact-format");
+  if (format !== void 0 && format !== "jsonl") {
+    throw new Error("--artifact-format only supports jsonl for user member/history-tag exports");
+  }
+  return format;
+}
+var listFlags = [projectIdFlag, queryFlag, fieldsFlag, directoryLimitFlag, offsetFlag, authenticatedOnlyFlag];
+var tagListFlags = [projectIdFlag, queryFlag, tagListFieldsFlag, directoryLimitFlag, offsetFlag, authenticatedOnlyFlag];
+var memberRunFlags = (memberFieldsFlag) => [
+  projectIdFlag,
+  propertyNamesFlag,
+  memberFieldsFlag,
+  queryFlag,
+  { name: "use-cache", type: "boolean", required: false, desc: "Whether to use query cache. Default: true." },
+  requestIdFlag,
+  memberLimitFlag,
+  syncTimeoutSecondsFlag
+];
+var memberExportFlags = (memberFieldsFlag) => [
+  projectIdFlag,
+  propertyNamesFlag,
+  memberFieldsFlag,
+  queryFlag,
+  { name: "use-cache", type: "boolean", required: false, desc: "Whether to use query cache. Default: true." },
+  requestIdFlag,
+  jsonlArtifactFormatFlag3,
+  asyncTimeoutSecondsFlag
+];
+var commands37 = [
+  capability("user-cluster", "list", "analysis.user_cluster.list", "List user clusters for discovery. Use offset only for stable asset browsing.", listFlags, "read", assetListInput),
+  capability("user-cluster", "get", "analysis.user_cluster.get", "Get user cluster details by exact cluster_name values.", [
+    projectIdFlag,
+    { name: "cluster-names", type: "json", required: true, desc: "JSON array of exact cluster_name values." }
+  ], "read", (ctx) => ({
+    project_id: ctx.num("project-id"),
+    cluster_names: ctx.json("cluster-names")
+  })),
+  capability("user-cluster-member", "list", "analysis.user_cluster_member.list", `Run a bounded user cluster member query. ${analysisDataRunRoutingHelp}`, [
+    clusterNameFlag,
+    ...memberRunFlags(clusterMemberFieldsFlag)
+  ], "read", (ctx) => memberInput(ctx, "cluster", true)),
+  capability("user-cluster-member", "export", "analysis.user_cluster_member.export", `Export user cluster members as a jsonl artifact. ${analysisDataExportRoutingHelp}`, [
+    clusterNameFlag,
+    ...memberExportFlags(clusterMemberFieldsFlag)
+  ], "read", (ctx) => memberInput(ctx, "cluster", false)),
+  capability("user-cluster", "create", "analysis.user_cluster.create", "Create a condition or SQL user cluster directly from an AI-facing definition request.", [
+    projectIdFlag,
+    clusterNameFlag,
+    displayNameFlag,
+    clusterDefinitionRequestFlag,
+    authenticatedOnlyFlag,
+    zoneOffsetFlag3,
+    entityIdFlag
+  ], "write", (ctx) => clusterWriteInput(ctx, true)),
+  capability("user-cluster", "update", "analysis.user_cluster.update", "Update a condition or SQL user cluster. Pass only fields that should change.", [
+    projectIdFlag,
+    clusterNameFlag,
+    optionalDisplayNameFlag,
+    optionalClusterDefinitionRequestFlag,
+    authenticatedOnlyFlag,
+    remarkFlag,
+    zoneOffsetFlag3
+  ], "write", (ctx) => clusterWriteInput(ctx, false)),
+  idImportCapability(capability("user-cluster", "create-id", "analysis.user_cluster.create_id", "Create a cluster by mapping imported values to an analysis entity.", [
+    projectIdFlag,
+    { ...clusterNameFlag, required: false, desc: "Optional cluster_name; generated if omitted." },
+    displayNameFlag,
+    requiredEntityIdFlag,
+    inputFileIdFlag,
+    clusterFileContentFlag,
+    remarksFlag,
+    associationPropertyFlag
+  ], "write", (ctx) => idClusterInput(ctx, true))),
+  idImportCapability(capability("user-cluster", "update-id", "analysis.user_cluster.update_id", "Update a cluster by remapping imported values to its analysis entity.", [
+    projectIdFlag,
+    clusterNameFlag,
+    optionalDisplayNameFlag,
+    inputFileIdFlag,
+    clusterFileContentFlag,
+    remarksFlag,
+    associationPropertyFlag
+  ], "write", (ctx) => idClusterInput(ctx, false))),
+  capability("user-cluster", "refresh", "analysis.user_cluster.refresh", "Refresh a user cluster by exact cluster_name.", [
+    projectIdFlag,
+    clusterNameFlag
+  ], "write", (ctx) => ({ project_id: ctx.num("project-id"), cluster_name: ctx.str("cluster-name") })),
+  capability("user-cluster", "delete", "analysis.user_cluster.delete", "Delete a user cluster by exact cluster_name after dependency review.", [
+    projectIdFlag,
+    clusterNameFlag,
+    confirmedFlag
+  ], "high-risk-write", (ctx) => compactInput({
+    project_id: ctx.num("project-id"),
+    cluster_name: ctx.str("cluster-name"),
+    confirmed: optionalBoolean2(ctx, "confirmed")
+  })),
+  capability("user-tag", "list", "analysis.user_tag.list", "List user tags for discovery. Returned identifiers use canonical tag_name. Use offset only for stable asset browsing.", tagListFlags, "read", assetListInput),
+  capability("user-tag", "get", "analysis.user_tag.get", "Get user tag details by exact tag_name values.", [
+    projectIdFlag,
+    { name: "tag-names", type: "json", required: true, desc: "JSON array of exact tag_name values." }
+  ], "read", (ctx) => ({
+    project_id: ctx.num("project-id"),
+    tag_names: ctx.json("tag-names")
+  })),
+  capability("user-tag-member", "list", "analysis.user_tag_member.list", `Run a bounded user tag member query. ${analysisDataRunRoutingHelp}`, [
+    tagNameFlag,
+    snapshotDateFlag,
+    ...memberRunFlags(tagMemberFieldsFlag)
+  ], "read", (ctx) => memberInput(ctx, "tag", true)),
+  capability("user-tag-member", "export", "analysis.user_tag_member.export", `Export user tag members as a jsonl artifact. ${analysisDataExportRoutingHelp}`, [
+    tagNameFlag,
+    snapshotDateFlag,
+    ...memberExportFlags(tagMemberFieldsFlag)
+  ], "read", (ctx) => memberInput(ctx, "tag", false)),
+  capability("user-tag", "create", "analysis.user_tag.create", "Create a user tag directly from an AI-facing definition request.", [
+    projectIdFlag,
+    tagNameFlag,
+    displayNameFlag,
+    tagDefinitionRequestFlag,
+    authenticatedOnlyFlag,
+    zoneOffsetFlag3,
+    entityIdFlag
+  ], "write", (ctx) => tagWriteInput(ctx, true)),
+  capability("user-tag", "update", "analysis.user_tag.update", "Update a user tag. Pass only fields that should change.", [
+    projectIdFlag,
+    tagNameFlag,
+    optionalDisplayNameFlag,
+    optionalTagDefinitionRequestFlag,
+    authenticatedOnlyFlag,
+    remarkFlag,
+    zoneOffsetFlag3
+  ], "write", (ctx) => tagWriteInput(ctx, false)),
+  capability("user-tag", "refresh", "analysis.user_tag.refresh", "Refresh a user tag by exact tag_name.", [
+    projectIdFlag,
+    tagNameFlag
+  ], "write", (ctx) => ({ project_id: ctx.num("project-id"), tag_name: ctx.str("tag-name") })),
+  idImportCapability(capability("user-tag", "create-id", "analysis.user_tag.create_id", "Create a tag by mapping imported values to an analysis entity.", [
+    projectIdFlag,
+    { ...tagNameFlag, required: false, desc: "Optional tag_name; generated if omitted." },
+    displayNameFlag,
+    requiredEntityIdFlag,
+    inputFileIdFlag,
+    tagFileContentFlag,
+    remarksFlag,
+    associationPropertyFlag
+  ], "write", (ctx) => idTagInput(ctx, true))),
+  idImportCapability(capability("user-tag", "update-id", "analysis.user_tag.update_id", "Update a tag by remapping imported values to its analysis entity.", [
+    projectIdFlag,
+    tagNameFlag,
+    optionalDisplayNameFlag,
+    entityIdFlag,
+    inputFileIdFlag,
+    tagFileContentFlag,
+    remarksFlag,
+    associationPropertyFlag
+  ], "write", (ctx) => idTagInput(ctx, false))),
+  capability("user-tag", "delete", "analysis.user_tag.delete", "Delete a user tag by exact tag_name after dependency review.", [
+    projectIdFlag,
+    tagNameFlag,
+    confirmedFlag
+  ], "high-risk-write", (ctx) => compactInput({
+    project_id: ctx.num("project-id"),
+    tag_name: ctx.str("tag-name"),
+    confirmed: optionalBoolean2(ctx, "confirmed")
+  })),
+  capability("history-tag", "list", "analysis.history_tag.list", "List history tag snapshots for a tag.", [
+    projectIdFlag,
+    tagNameFlag
+  ], "read", (ctx) => ({ project_id: ctx.num("project-id"), tag_name: ctx.str("tag-name") })),
+  capability("history-tag", "refresh", "analysis.history_tag.refresh", "Refresh one history tag snapshot.", [
+    projectIdFlag,
+    tagNameFlag,
+    refreshDateFlag,
+    { name: "use-user-table-type", type: "string", required: false, desc: "Optional source strategy: user_table, user_backup_table_default, or user_backup_table_last_date." }
+  ], "write", (ctx) => compactInput({
+    project_id: ctx.num("project-id"),
+    tag_name: ctx.str("tag-name"),
+    refresh_date: ctx.str("refresh-date"),
+    use_user_table_type: optionalString2(ctx, "use-user-table-type")
+  })),
+  capability("history-tag", "batch-refresh", "analysis.history_tag.batch_refresh", "Batch refresh history tag snapshots using the product refresh request object.", [
+    projectIdFlag,
+    tagNameFlag,
+    { name: "refresh-request", type: "json", required: true, desc: "Snake_case object: {start_time,end_time,only_abnormal?,use_user_table_type?}. Dates use yyyy-MM-dd; see history_tag_batch_refresh.md." }
+  ], "write", (ctx) => ({
+    project_id: ctx.num("project-id"),
+    tag_name: ctx.str("tag-name"),
+    refresh_request: ctx.json("refresh-request")
+  })),
+  capability("history-tag", "clear", "analysis.history_tag.clear", "Clear history tag snapshots in a date range after explicit confirmation.", [
+    projectIdFlag,
+    tagNameFlag,
+    { name: "start-time", type: "string", required: true, desc: "Start date, yyyy-MM-dd." },
+    { name: "end-time", type: "string", required: true, desc: "End date, yyyy-MM-dd." },
+    confirmedFlag
+  ], "high-risk-write", (ctx) => compactInput({
+    project_id: ctx.num("project-id"),
+    tag_name: ctx.str("tag-name"),
+    start_time: ctx.str("start-time"),
+    end_time: ctx.str("end-time"),
+    confirmed: optionalBoolean2(ctx, "confirmed")
+  })),
+  capability("history-tag-data", "run", "analysis.history_tag_data.run", `Run a bounded history tag statistics query. ${analysisDataRunRoutingHelp}`, [
+    projectIdFlag,
+    tagNameFlag,
+    historyViewFlag,
+    requestIdFlag,
+    limitFlag,
+    syncTimeoutSecondsFlag
+  ], "read", (ctx) => historyTagDataInput(ctx, true)),
+  capability("history-tag-data", "export", "analysis.history_tag_data.export", `Export history tag statistics as a jsonl artifact. ${analysisDataExportRoutingHelp}`, [
+    projectIdFlag,
+    tagNameFlag,
+    historyViewFlag,
+    requestIdFlag,
+    jsonlArtifactFormatFlag3,
+    asyncTimeoutSecondsFlag
+  ], "read", (ctx) => historyTagDataInput(ctx, false)),
+  capability("history-tag-data-drilldown", "run", "analysis.history_tag_data_drilldown.run", `Run a bounded drilldown user query for one history tag statistic value. ${analysisDataRunRoutingHelp}`, [
+    tagNameFlag,
+    { ...snapshotDateFlag, required: true, desc: "History tag snapshot date, yyyy-MM-dd." },
+    groupColFlag,
+    historyViewFlag,
+    ...memberRunFlags(tagMemberFieldsFlag)
+  ], "read", (ctx) => historyTagDataDrilldownInput(ctx, true)),
+  capability("history-tag-data-drilldown", "export", "analysis.history_tag_data_drilldown.export", `Export drilldown users for one history tag statistic value as a jsonl artifact. ${analysisDataExportRoutingHelp}`, [
+    tagNameFlag,
+    { ...snapshotDateFlag, required: true, desc: "History tag snapshot date, yyyy-MM-dd." },
+    groupColFlag,
+    historyViewFlag,
+    ...memberExportFlags(tagMemberFieldsFlag)
+  ], "read", (ctx) => historyTagDataDrilldownInput(ctx, false))
+];
+var user_default = commands37;
+
+// src/commands/te-analysis/global/list-query-clusters.ts
+var listQueryClusters = createMcpCommand({
+  command: "+list_query_clusters",
+  description: "List query cluster options accessible to the current account in the project. Use this to decide whether to query the current self cluster, global aggregated data, or one specific slave cluster.",
+  flags: [
+    { name: "project_id", type: "number", required: true, desc: "Project ID used to resolve cluster query permissions", alias: "p" }
+  ],
+  risk: "read",
+  buildArgs: (ctx) => ({
+    projectId: ctx.num("project_id")
+  })
+});
+
+// src/commands/te-analysis/global/index.ts
+var commands38 = [
+  listQueryClusters
+];
+var global_default = commands38;
+
+// src/commands/te-analysis/sql-table/columns.ts
+var sqlTableColumns = createAnalysisCapabilityCommand({
+  resource: "sql-table",
+  command: "columns",
+  capabilityId: "analysis.sql_table.columns",
+  description: 'List columns for an exact server-authorized SQL table reference. When copying a Trino column containing #, $, @, spaces, or punctuation into SQL, delimit the identifier with double quotes, for example "#user_id" or "$part_event". Queries against an event table must include a date-partition predicate on the quoted "$part_date" column; the backend rejects event-table SQL without it.',
+  flags: [
+    projectIdFlag,
+    {
+      name: "table-ref",
+      type: "string",
+      required: true,
+      desc: "Exact table_ref returned by analysis sql-table list; a unique table-only reference is also accepted."
+    },
+    sqlTableUsageFlag
+  ],
+  risk: "read",
+  buildInput: (ctx) => compactInput({
+    ...projectInput(ctx),
+    table_ref: ctx.str("table-ref"),
+    usage: optionalString2(ctx, "usage")
+  })
+});
+
+// src/commands/te-analysis/sql-table/list.ts
+var sqlTableList = createAnalysisCapabilityCommand({
+  resource: "sql-table",
+  command: "list",
+  capabilityId: "analysis.sql_table.list",
+  description: "List server-authoritative SQL table references queryable by the current user in a project.",
+  flags: [projectIdFlag, queryFlag, directoryLimitFlag, offsetFlag, sqlTableUsageFlag],
+  risk: "read",
+  buildInput: (ctx) => compactInput({
+    project_id: ctx.num("project-id"),
+    query: optionalString2(ctx, "query"),
+    limit: optionalNumber2(ctx, "limit"),
+    offset: optionalNumber2(ctx, "offset"),
+    usage: optionalString2(ctx, "usage")
+  })
+});
+
+// src/commands/te-analysis/sql-table/index.ts
+var commands39 = [sqlTableList, sqlTableColumns];
+var sql_table_default = commands39;
+
+// src/commands/te-analysis/entity/id-import-options.ts
+var entityIdImportOptions = createAnalysisCapabilityCommand({
+  resource: "entity",
+  command: "id-import-options",
+  capabilityId: "analysis.entity.id_import_options",
+  description: "Discover the authoritative ID-import mapping contract for one analysis entity.",
+  flags: [
+    projectIdFlag,
+    {
+      name: "entity-id",
+      type: "number",
+      required: true,
+      desc: "Analysis entity ID. Discover it from project entity metadata; do not guess."
+    }
+  ],
+  risk: "read",
+  buildInput: (ctx) => ({
+    project_id: ctx.num("project-id"),
+    entity_id: ctx.num("entity-id")
+  })
+});
+
+// src/commands/te-analysis/entity/index.ts
+var commands40 = [entityIdImportOptions];
+var entity_default = commands40;
+
+// src/commands/te-analysis/input-file/inspect.ts
+var inputFileInspect = {
+  service: "analysis",
+  resource: "input-file",
+  command: "inspect",
+  description: "Inspect an uploaded analysis input file owned by the current user.",
+  flags: [
+    { name: "input-file-id", type: "string", required: true, desc: "Uploaded input file ID, for example ifile_<32 lowercase hex>." }
+  ],
+  risk: "read",
+  dryRun: (ctx) => ({
+    method: "GET",
+    url: `${ctx.host()}/api/cli/${resolveGatewayDomain("analysis")}/v1/input-files/${ctx.str("input-file-id")}`
+  }),
+  execute: async (ctx) => {
+    const inputFileId = ctx.str("input-file-id");
+    const result = await requestCapabilityGateway(
+      ctx.host(),
+      resolveGatewayDomain("analysis"),
+      `input-files/${inputFileId}`
+    );
+    return {
+      ...result,
+      inspect_path: `/api/cli/analysis/v1/input-files/${inputFileId}`,
+      inspect_command: `ae-cli analysis input-file inspect --input-file-id ${inputFileId}`
+    };
+  }
+};
+
+// src/commands/te-analysis/input-file/purpose-list.ts
+var inputFilePurposeList = createAnalysisCapabilityCommand({
+  resource: "input-file purpose",
+  command: "list",
+  capabilityId: "analysis.input_file.purpose.list",
+  description: "List input-file purposes the current user may upload in a project.",
+  flags: [projectIdFlag],
+  risk: "read",
+  buildInput: (ctx) => ({ project_id: ctx.num("project-id") })
+});
+
+// src/commands/te-analysis/input-file/upload.ts
+var inputFileUpload = {
+  service: "analysis",
+  resource: "input-file",
+  command: "upload",
+  description: "Upload a local file to the analysis capability gateway and return an input_file_id.",
+  flags: [
+    { name: "project-id", type: "number", required: true, desc: "Numeric project ID.", alias: "p" },
+    { name: "purpose", type: "string", required: true, desc: "Purpose returned by analysis input-file purpose list." },
+    { name: "file", type: "string", required: true, desc: "Local file path to upload." }
+  ],
+  risk: "write",
+  dryRun: (ctx) => ({
+    method: "POST",
+    url: buildCapabilityGatewayUrl(ctx.host(), resolveGatewayDomain("analysis"), "input-files"),
+    body: {
+      multipart: {
+        project_id: ctx.num("project-id"),
+        purpose: ctx.str("purpose"),
+        file: ctx.str("file")
+      }
+    }
+  }),
+  execute: async (ctx) => {
+    const result = await uploadInputFile(
+      ctx.host(),
+      resolveGatewayDomain("analysis"),
+      ctx.num("project-id"),
+      ctx.str("purpose"),
+      ctx.str("file")
+    );
+    const inputFileId = result?.input_file_id ?? result?.inputFileId;
+    return {
+      ...result,
+      inspect_path: typeof inputFileId === "string" ? `/api/cli/analysis/v1/input-files/${inputFileId}` : result?.inspect_path,
+      inspect_command: typeof inputFileId === "string" ? `ae-cli analysis input-file inspect --input-file-id ${inputFileId}` : void 0
+    };
+  }
+};
+
+// src/commands/te-analysis/input-file/index.ts
+var commands41 = [inputFileUpload, inputFileInspect, inputFilePurposeList];
+var input_file_default = commands41;
+
+// src/commands/te-analysis/index.ts
+registerCapabilityGatewayRoute("analysis", { gatewayDomain: "analysis" });
+var baseCommands = [
+  ...meta_default,
+  ...governance_default,
+  ...report_default,
+  ...report_data_default,
+  ...report_change_log_default,
+  ...report_version_default,
+  ...report_abnormal_default,
+  ...dashboard_default,
+  ...dashboard_report_default,
+  ...dashboard_report_data_default,
+  ...query_default,
+  ...run_default,
+  ...artifact_default,
+  ...adhoc_default,
+  ...dashboard_definition_default,
+  ...dashboard_daily_report_default,
+  ...bi_panel_default,
+  ...bi_panel_version_default,
+  ...bi_panel_page_data_default,
+  ...project_space_default,
+  ...favorite_default,
+  ...public_link_default,
+  ...model_default,
+  ...event_detail_default,
+  ...entity_detail_default,
+  ...drilldown_users_default,
+  ...drilldown_user_events_default,
+  ...user_default,
+  ...sql_table_default,
+  ...entity_default,
+  ...input_file_default
+];
+var commands42 = [
+  ...baseCommands,
+  ...isGlobalQueryModeEnabled() ? global_default : []
+];
+var te_analysis_default = commands42;
+export {
+  baseCommands,
+  te_analysis_default as default
+};