@thinkingai/ae-cli 6.1.10 → 6.1.12

package/dist/{te-engage-NLZUPSBK.js → te-engage-L72HWRGO.js}

@@ -1,18 +1,20 @@
 import {
   createCapabilityCommand
-} from "./chunk-PVBYJWC2.js";
+} from "./chunk-TS6BUGUY.js";
 import {
   registerCapabilityGatewayRoute
 } from "./chunk-PTE56QPL.js";
-import "./chunk-HQ2A7ITL.js";
 import {
   printError
-} from "./chunk-KTYR3U6D.js";
-import "./chunk-E7UXXHO3.js";
-import "./chunk-IR4ZLVPW.js";
-import "./chunk-V6FR6WTW.js";
-import "./chunk-24BAVOX3.js";
-import "./chunk-LYVNONC4.js";
+} from "./chunk-YTG6Q75E.js";
+import "./chunk-GS2P7LFD.js";
+import "./chunk-Z3OXWCIA.js";
+import "./chunk-YV52FB5G.js";
+import "./chunk-GJJA4CQZ.js";
+import {
+  CliValidationError
+} from "./chunk-AXDXJTPC.js";
+import "./chunk-JHENBQ5B.js";
 
 // src/commands/te-engage/shared.ts
 function createEngageCapabilityCommand(cliService, config) {
@@ -207,6 +209,362 @@ var flowModifyBaseInfo = createEngageFlowCapabilityCommand({
   })
 });
 
+// src/commands/te-engage/semantic-qp-validation.ts
+var OPERATORS = /* @__PURE__ */ new Set([
+  "eq",
+  "neq",
+  "lt",
+  "lte",
+  "gt",
+  "gte",
+  "exists",
+  "not_exists",
+  "between",
+  "contains",
+  "not_contains",
+  "is_true",
+  "is_false",
+  "regex",
+  "not_regex",
+  "relative_current_time",
+  "relative_event_time",
+  "array_contains",
+  "in_cluster",
+  "not_in_cluster"
+]);
+var AUDIENCE_AGGREGATIONS = /* @__PURE__ */ new Set([
+  "count",
+  "active_days",
+  "sum",
+  "avg",
+  "max",
+  "min",
+  "distinct_count"
+]);
+var METRIC_AGGREGATIONS = /* @__PURE__ */ new Set([
+  "total_count",
+  "user_count",
+  "per_user_count",
+  "sum",
+  "avg",
+  "avg_per_user",
+  "max",
+  "min",
+  "distinct_count",
+  "median",
+  "percentile",
+  "variance",
+  "stddev"
+]);
+function validateSemanticAudienceDefinition(value, path) {
+  const definition = object(value, path);
+  rejectUnknown(definition, ["type", "conditions", "include_filter", "exclude_filter"], path);
+  exactString(definition.type, "condition", `${path}.type`);
+  validateGroup(definition.conditions, `${path}.conditions`);
+  optional(definition.include_filter, (item) => validateGroup(item, `${path}.include_filter`));
+  optional(definition.exclude_filter, (item) => validateGroup(item, `${path}.exclude_filter`));
+}
+function validateSemanticEventDefinition(value, path) {
+  const event = object(value, path);
+  rejectUnknown(event, [
+    "type",
+    "event",
+    "operator",
+    "value",
+    "aggregation",
+    "property",
+    "time_range",
+    "filters"
+  ], path);
+  exactString(event.type, "event", `${path}.type`);
+  nonBlankString(event.event, `${path}.event`);
+  optionalEnum(event.operator, OPERATORS, `${path}.operator`);
+  optionalNumber(event.value, `${path}.value`);
+  optionalEnum(event.aggregation, AUDIENCE_AGGREGATIONS, `${path}.aggregation`);
+  optionalString(event.property, `${path}.property`);
+  optional(event.time_range, (item) => validateTimeRange(item, `${path}.time_range`));
+  optional(event.filters, (item) => validateFilterGroup(item, `${path}.filters`));
+}
+function validateSemanticMetricDefinition(value, path) {
+  const metric = object(value, path);
+  if (metric.type === "event") {
+    validateMetricEvent(metric, path, false);
+    return;
+  }
+  if (metric.type === "formula") {
+    rejectUnknown(metric, ["type", "expression", "dependencies", "format"], path);
+    nonBlankString(metric.expression, `${path}.expression`);
+    optionalString(metric.format, `${path}.format`);
+    array(metric.dependencies, `${path}.dependencies`, 1).forEach((dependency, index) => validateMetricEvent(
+      object(dependency, `${path}.dependencies[${index}]`),
+      `${path}.dependencies[${index}]`,
+      true
+    ));
+    return;
+  }
+  invalid(`${path}.type must be event or formula.`);
+}
+function validateEmbeddedSemanticDefinitions(value, path) {
+  walk(value, path);
+}
+function walk(value, path) {
+  if (Array.isArray(value)) {
+    value.forEach((item, index) => walk(item, `${path}[${index}]`));
+    return;
+  }
+  if (!isObject(value)) return;
+  for (const [key, item] of Object.entries(value)) {
+    const itemPath = `${path}.${key}`;
+    if (item === void 0 || item === null) continue;
+    if (["definitionRequest", "targetDefinitionRequest", "topicDefinitionRequest"].includes(key)) {
+      validateSemanticAudienceDefinition(item, itemPath);
+    } else if (key === "eventDefinition") {
+      validateSemanticEventDefinition(item, itemPath);
+    } else if (key === "triggerDefinition") {
+      validateTriggerDefinition(item, itemPath);
+    } else if (key === "config" && typeof item === "string") {
+      walkJsonString(item, itemPath);
+    } else {
+      walk(item, itemPath);
+    }
+  }
+}
+function validateTriggerDefinition(value, path) {
+  const definition = object(value, path);
+  rejectUnknown(definition, ["rules"], path);
+  array(definition.rules, `${path}.rules`, 1).forEach((ruleValue, ruleIndex) => {
+    const rulePath = `${path}.rules[${ruleIndex}]`;
+    const rule = object(ruleValue, rulePath);
+    array(rule.events, `${rulePath}.events`, 1).forEach((event, eventIndex) => {
+      const eventPath = `${rulePath}.events[${eventIndex}]`;
+      const candidate = object(event, eventPath);
+      if ("eventDefinition" in candidate) {
+        validateSemanticEventDefinition(candidate.eventDefinition, `${eventPath}.eventDefinition`);
+      } else {
+        validateSemanticEventDefinition(candidate, eventPath);
+      }
+    });
+    optional(rule.blackList, (items) => array(items, `${rulePath}.blackList`).forEach((event, index) => validateSemanticEventDefinition(
+      event,
+      `${rulePath}.blackList[${index}]`
+    )));
+  });
+}
+function validateGroup(value, path) {
+  const group = object(value, path);
+  rejectUnknown(group, ["relation", "items"], path);
+  enumValue(group.relation, /* @__PURE__ */ new Set(["and", "or"]), `${path}.relation`);
+  array(group.items, `${path}.items`, 1).forEach((item, index) => validateCondition(item, `${path}.items[${index}]`));
+}
+function validateCondition(value, path) {
+  const condition = object(value, path);
+  switch (condition.type) {
+    case "event":
+      validateSemanticEventDefinition(condition, path);
+      required(condition.time_range, `${path}.time_range`);
+      return;
+    case "user":
+    case "tag":
+    case "cluster":
+      validatePropertyCondition(condition, path);
+      return;
+    case "compound":
+      rejectUnknown(condition, ["type", "group"], path);
+      validateGroup(condition.group, `${path}.group`);
+      return;
+    case "behavior_sequence":
+      validateBehaviorSequence(condition, path);
+      return;
+    default:
+      invalid(`${path}.type is unsupported.`);
+  }
+}
+function validatePropertyCondition(condition, path) {
+  const extended = condition.type === "tag" || condition.type === "cluster";
+  rejectUnknown(condition, [
+    "type",
+    "field",
+    "operator",
+    "values",
+    "time_relative",
+    "time_unit",
+    ...extended ? ["cluster_date_policy", "specified_cluster_date"] : []
+  ], path);
+  validateField(condition.field, `${path}.field`);
+  if (condition.type === "user") enumValue(condition.operator, OPERATORS, `${path}.operator`);
+  else optionalEnum(condition.operator, OPERATORS, `${path}.operator`);
+  optional(condition.values, (item) => array(item, `${path}.values`));
+  optionalString(condition.time_relative, `${path}.time_relative`);
+  optionalString(condition.time_unit, `${path}.time_unit`);
+  optionalString(condition.cluster_date_policy, `${path}.cluster_date_policy`);
+  optionalString(condition.specified_cluster_date, `${path}.specified_cluster_date`);
+}
+function validateBehaviorSequence(condition, path) {
+  rejectUnknown(condition, ["type", "completed", "steps", "time_range", "window"], path);
+  if (typeof condition.completed !== "boolean") invalid(`${path}.completed must be a boolean.`);
+  array(condition.steps, `${path}.steps`, 1).forEach((stepValue, index) => {
+    const stepPath = `${path}.steps[${index}]`;
+    const step = object(stepValue, stepPath);
+    rejectUnknown(step, ["event", "completed", "filters", "relative_to_first", "window"], stepPath);
+    nonBlankString(step.event, `${stepPath}.event`);
+    optionalBoolean(step.completed, `${stepPath}.completed`);
+    optionalBoolean(step.relative_to_first, `${stepPath}.relative_to_first`);
+    if (index === 1 && step.relative_to_first === true) {
+      invalid(`${stepPath}.relative_to_first must be false or omitted for the second step.`);
+    }
+    optional(step.filters, (item) => validateFilterGroup(item, `${stepPath}.filters`));
+    optional(step.window, (item) => validateWindow(item, `${stepPath}.window`));
+  });
+  required(condition.time_range, `${path}.time_range`);
+  validateTimeRange(condition.time_range, `${path}.time_range`);
+  optional(condition.window, (item) => validateWindow(item, `${path}.window`));
+}
+function validateFilterGroup(value, path) {
+  const group = object(value, path);
+  rejectUnknown(group, ["relation", "items"], path);
+  optionalEnum(group.relation, /* @__PURE__ */ new Set(["and", "or"]), `${path}.relation`);
+  array(group.items, `${path}.items`, 1).forEach((filterValue, index) => {
+    const filterPath = `${path}.items[${index}]`;
+    const filter = object(filterValue, filterPath);
+    rejectUnknown(filter, ["field", "operator", "values"], filterPath);
+    validateField(filter.field, `${filterPath}.field`);
+    enumValue(filter.operator, OPERATORS, `${filterPath}.operator`);
+    optional(filter.values, (item) => array(item, `${filterPath}.values`));
+  });
+}
+function validateField(value, path) {
+  if (typeof value === "string") {
+    nonBlankString(value, path);
+    return;
+  }
+  const field = object(value, path);
+  rejectUnknown(field, ["name", "type"], path);
+  nonBlankString(field.name, `${path}.name`);
+  optionalEnum(field.type, /* @__PURE__ */ new Set([
+    "event_property",
+    "user_property",
+    "tag",
+    "cluster"
+  ]), `${path}.type`);
+}
+function validateTimeRange(value, path) {
+  const range = object(value, path);
+  rejectUnknown(range, ["mode", "unit", "value", "start_time", "end_time"], path);
+  if (range.mode === "custom") {
+    nonBlankString(range.start_time, `${path}.start_time`);
+    nonBlankString(range.end_time, `${path}.end_time`);
+    return;
+  }
+  enumValue(range.mode, /* @__PURE__ */ new Set(["recent", "previous"]), `${path}.mode`);
+  optional(range.unit, (unit) => exactString(unit, "day", `${path}.unit`));
+  positiveInteger(range.value, `${path}.value`);
+}
+function validateWindow(value, path) {
+  const window = object(value, path);
+  rejectUnknown(window, ["value", "unit"], path);
+  positiveInteger(window.value, `${path}.value`);
+  nonBlankString(window.unit, `${path}.unit`);
+}
+function validateMetricEvent(metric, path, dependency) {
+  rejectUnknown(metric, [
+    "type",
+    ...dependency ? ["key"] : [],
+    "event",
+    "aggregation",
+    "property",
+    "percentile",
+    "filters",
+    "display_name"
+  ], path);
+  exactString(metric.type, "event", `${path}.type`);
+  if (dependency) nonBlankString(metric.key, `${path}.key`);
+  nonBlankString(metric.event, `${path}.event`);
+  enumValue(metric.aggregation, METRIC_AGGREGATIONS, `${path}.aggregation`);
+  if (!["total_count", "user_count", "per_user_count"].includes(String(metric.aggregation))) {
+    nonBlankString(metric.property, `${path}.property`);
+  }
+  optionalString(metric.property, `${path}.property`);
+  if (metric.aggregation === "percentile") {
+    optionalNumber(metric.percentile, `${path}.percentile`);
+    if (typeof metric.percentile !== "number" || metric.percentile <= 0 || metric.percentile > 100) {
+      invalid(`${path}.percentile must be greater than 0 and at most 100.`);
+    }
+  } else if (metric.percentile !== void 0 && metric.percentile !== null) {
+    invalid(`${path}.percentile is only valid for percentile aggregation.`);
+  }
+  optionalString(metric.display_name, `${path}.display_name`);
+  optional(metric.filters, (item) => validateFilterGroup(item, `${path}.filters`));
+}
+function walkJsonString(value, path) {
+  try {
+    walk(JSON.parse(value), path);
+  } catch (error) {
+    if (error instanceof SyntaxError) invalid(`${path} must contain valid JSON.`);
+    throw error;
+  }
+}
+function object(value, path) {
+  if (!isObject(value)) invalid(`${path} must be a JSON object.`);
+  return value;
+}
+function isObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function array(value, path, minLength = 0) {
+  if (!Array.isArray(value) || value.length < minLength) {
+    invalid(`${path} must be an array with at least ${minLength} item(s).`);
+  }
+  return value;
+}
+function rejectUnknown(value, allowed, path) {
+  const supported = new Set(allowed);
+  const unknown = Object.keys(value).find((key) => !supported.has(key));
+  if (unknown) invalid(`Unsupported field ${path}.${unknown}.`);
+}
+function optional(value, validate) {
+  if (value !== void 0 && value !== null) validate(value);
+}
+function required(value, path) {
+  if (value === void 0 || value === null) invalid(`${path} is required.`);
+}
+function nonBlankString(value, path) {
+  if (typeof value !== "string" || value.trim() === "") {
+    invalid(`${path} must be a non-blank string.`);
+  }
+}
+function optionalString(value, path) {
+  optional(value, (item) => nonBlankString(item, path));
+}
+function exactString(value, expected, path) {
+  if (value !== expected) invalid(`${path} must be ${expected}.`);
+}
+function enumValue(value, allowed, path) {
+  if (typeof value !== "string" || !allowed.has(value)) {
+    invalid(`${path} must be one of: ${[...allowed].join(", ")}.`);
+  }
+}
+function optionalEnum(value, allowed, path) {
+  optional(value, (item) => enumValue(item, allowed, path));
+}
+function optionalNumber(value, path) {
+  optional(value, (item) => {
+    if (typeof item !== "number" || !Number.isFinite(item)) invalid(`${path} must be a number.`);
+  });
+}
+function positiveInteger(value, path) {
+  if (!Number.isInteger(value) || value < 1) {
+    invalid(`${path} must be a positive integer.`);
+  }
+}
+function optionalBoolean(value, path) {
+  optional(value, (item) => {
+    if (typeof item !== "boolean") invalid(`${path} must be a boolean.`);
+  });
+}
+function invalid(message) {
+  throw new CliValidationError(message);
+}
+
 // src/commands/te-engage/engage-flow/flow/save.ts
 var allowedOperations = ["build", "preview", "commit"];
 function readRequest(ctx) {
@@ -221,6 +579,7 @@ function readRequest(ctx) {
   if ("sourceFlowUuid" in req) {
     throw new Error("Flag --req.sourceFlowUuid is unsupported; get the source flow and build nodes/edges instead");
   }
+  validateEmbeddedSemanticDefinitions(req, "--req");
   return req;
 }
 var flowSave = createEngageFlowCapabilityCommand({
@@ -230,7 +589,12 @@ var flowSave = createEngageFlowCapabilityCommand({
   description: "Build, preview, or commit an operation-based flow draft.",
   flags: [
     { name: "project-id", type: "number", required: true, alias: "p", desc: "Numeric project ID." },
-    { name: "req", type: "json", required: true, desc: "Operation-based flow save request JSON object." }
+    {
+      name: "req",
+      type: "json",
+      required: true,
+      desc: "Operation-based flow save request. Custom audience node configs and branches use targetDefinitionRequest."
+    }
   ],
   risk: "write",
   validate: (ctx) => {
@@ -1030,16 +1394,22 @@ var presetEventUpdate = createEngageSettingCapabilityCommand({
   description: "Update the project's preset metric event config (add/active/recharge event definitions).",
   flags: [
     { name: "project-id", type: "number", required: true, alias: "p", desc: "Numeric project ID." },
-    { name: "add-event-desc", type: "string", required: false, desc: "Add-event qp definition." },
-    { name: "active-event-desc", type: "string", required: false, desc: "Active-event qp definition." },
-    { name: "recharge-event-desc", type: "string", required: false, desc: "Recharge-success-event qp definition." }
+    { name: "add-event-definition", type: "json", required: false, desc: "Semantic add-event definition." },
+    { name: "active-event-definition", type: "json", required: false, desc: "Semantic active-event definition." },
+    { name: "recharge-event-definition", type: "json", required: false, desc: "Semantic recharge event definition." }
   ],
   risk: "write",
+  validate: (ctx) => {
+    for (const name of ["add-event-definition", "active-event-definition", "recharge-event-definition"]) {
+      const definition = ctx.json(name);
+      if (definition !== void 0) validateSemanticEventDefinition(definition, `--${name}`);
+    }
+  },
   buildInput: (ctx) => ({
     project_id: ctx.num("project-id"),
-    add_event_desc: ctx.str("add-event-desc") || void 0,
-    active_event_desc: ctx.str("active-event-desc") || void 0,
-    recharge_event_desc: ctx.str("recharge-event-desc") || void 0
+    add_event_definition: ctx.json("add-event-definition") || void 0,
+    active_event_definition: ctx.json("active-event-definition") || void 0,
+    recharge_event_definition: ctx.json("recharge-event-definition") || void 0
   })
 });
 
@@ -1077,34 +1447,8 @@ var commonMetricGet = createEngageSettingCapabilityCommand({
 
 // src/commands/te-engage/engage-setting/common-metric/metric-qp-validation.ts
 var VALID_WINDOW_TIME_UNITS = /* @__PURE__ */ new Set(["minute", "hour", "day"]);
-function validateMetricQpFlag(metricQp) {
-  let parsed;
-  try {
-    parsed = JSON.parse(metricQp);
-  } catch {
-    printError(
-      "validation",
-      "--metric-qp must be a valid JSON object string.",
-      "Discover events via analysis-meta event list, then assemble a type=0/1 metric QP object."
-    );
-    process.exit(1);
-  }
-  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
-    printError(
-      "validation",
-      "--metric-qp must be a JSON object string.",
-      'Do not pass placeholders like "event"; pass a complete metric QP object.'
-    );
-    process.exit(1);
-  }
-  if (Object.keys(parsed).length === 0) {
-    printError(
-      "validation",
-      "--metric-qp cannot be an empty JSON object.",
-      "Pass a complete metric QP expression instead of {}."
-    );
-    process.exit(1);
-  }
+function validateMetricDefinitionFlag(definition) {
+  validateSemanticMetricDefinition(definition, "--metric-definition");
 }
 function validateMetricWindowTimeUnitFlag(unit) {
   if (VALID_WINDOW_TIME_UNITS.has(unit)) {
@@ -1135,10 +1479,10 @@ var writeFlags = [
   { name: "metric-type", type: "number", required: true, desc: "Metric type; create requires 1 (PRESET)." },
   { name: "metric-name", type: "string", required: true, desc: "Metric name (^[a-z][0-9a-z_]{0,79}$)." },
   {
-    name: "metric-qp",
-    type: "string",
+    name: "metric-definition",
+    type: "json",
     required: true,
-    desc: "Complete metric QP JSON object string (type=0 event or type=1 formula)."
+    desc: "Semantic event or formula metric definition."
   },
   { name: "metric-window-num", type: "number", required: true, desc: "Metric window number." },
   {
@@ -1157,7 +1501,7 @@ var buildWriteInput = (ctx) => ({
   project_id: ctx.num("project-id"),
   metric_type: ctx.num("metric-type"),
   metric_name: ctx.str("metric-name"),
-  metric_qp: ctx.str("metric-qp"),
+  metric_definition: ctx.json("metric-definition"),
   metric_window_num: ctx.num("metric-window-num"),
   metric_window_time_unit: ctx.str("metric-window-time-unit"),
   display_name: ctx.str("display-name"),
@@ -1170,12 +1514,12 @@ var commonMetricCreate = createEngageSettingCapabilityCommand({
   resource: "common-metric",
   command: "create",
   capabilityId: "engage-setting.common-metric.create",
-  description: "Create a PRESET common metric with its event/formula QP, time window, and display metadata.",
+  description: "Create a PRESET common metric from a semantic event/formula definition.",
   flags: writeFlags,
   risk: "write",
   validate: (ctx) => {
     validatePresetMetricTypeFlag(ctx.num("metric-type"));
-    validateMetricQpFlag(ctx.str("metric-qp"));
+    validateMetricDefinitionFlag(ctx.json("metric-definition"));
     validateMetricWindowTimeUnitFlag(ctx.str("metric-window-time-unit"));
   },
   buildInput: buildWriteInput
@@ -1187,10 +1531,10 @@ var writeFlags2 = [
   { name: "metric-type", type: "number", required: true, desc: "Metric type; use 1 (PRESET) for common metrics." },
   { name: "metric-name", type: "string", required: true, desc: "Metric name (existing PRESET metric)." },
   {
-    name: "metric-qp",
-    type: "string",
+    name: "metric-definition",
+    type: "json",
     required: true,
-    desc: "Complete metric QP JSON object string (type=0 event or type=1 formula)."
+    desc: "Semantic event or formula metric definition."
   },
   { name: "metric-window-num", type: "number", required: true, desc: "Metric window number." },
   {
@@ -1209,7 +1553,7 @@ var buildWriteInput2 = (ctx) => ({
   project_id: ctx.num("project-id"),
   metric_type: ctx.num("metric-type"),
   metric_name: ctx.str("metric-name"),
-  metric_qp: ctx.str("metric-qp"),
+  metric_definition: ctx.json("metric-definition"),
   metric_window_num: ctx.num("metric-window-num"),
   metric_window_time_unit: ctx.str("metric-window-time-unit"),
   display_name: ctx.str("display-name"),
@@ -1226,7 +1570,7 @@ var commonMetricUpdate = createEngageSettingCapabilityCommand({
   flags: writeFlags2,
   risk: "write",
   validate: (ctx) => {
-    validateMetricQpFlag(ctx.str("metric-qp"));
+    validateMetricDefinitionFlag(ctx.json("metric-definition"));
     validateMetricWindowTimeUnitFlag(ctx.str("metric-window-time-unit"));
   },
   buildInput: buildWriteInput2
@@ -1249,44 +1593,6 @@ var commonMetricDelete = createEngageSettingCapabilityCommand({
   })
 });
 
-// src/commands/te-engage/engage-setting/query/cluster-qp-skill.ts
-var queryClusterQpSkill = createEngageSettingCapabilityCommand({
-  resource: "query",
-  command: "cluster-qp-skill",
-  capabilityId: "engage-setting.query.cluster-qp-skill",
-  description: "Query the mix-cluster QP skill definition for audience, trigger, and completion event objects. Returns skill text (not final QP JSON). Use it before save when build-save-guide requires targetConfig.qp, triggerConfig.triggerRule, clientConfig.clientQp, or completionIndicatorDef.event.",
-  flags: [
-    { name: "project-id", type: "number", required: true, alias: "p", desc: "Numeric project ID." },
-    {
-      name: "response-mode",
-      type: "string",
-      required: false,
-      desc: "Skill content mode: base, examples, or full. Default: full."
-    },
-    {
-      name: "condition-subtype",
-      type: "string",
-      required: false,
-      desc: "Condition subtype selector: core, behavior_seq, or all. Default: all."
-    }
-  ],
-  risk: "read",
-  buildInput: (ctx) => {
-    const input = {
-      project_id: ctx.num("project-id")
-    };
-    const responseMode = ctx.str("response-mode");
-    const conditionSubtype = ctx.str("condition-subtype");
-    if (responseMode) {
-      input.response_mode = responseMode;
-    }
-    if (conditionSubtype) {
-      input.condition_subtype = conditionSubtype;
-    }
-    return input;
-  }
-});
-
 // src/commands/te-engage/engage-setting/index.ts
 var commands2 = [
   channelTouchLimitsList,
@@ -1326,8 +1632,7 @@ var commands2 = [
   commonMetricGet,
   commonMetricCreate,
   commonMetricUpdate,
-  commonMetricDelete,
-  queryClusterQpSkill
+  commonMetricDelete
 ];
 var engage_setting_default = commands2;
 
@@ -1620,21 +1925,31 @@ var presetMetricSet = createEngageSceneCapabilityCommand({
   resource: "preset-metric",
   command: "set",
   capabilityId: "engage-scene.preset-metric.set",
-  description: "Set preset metric QP config (impression/click/attend) of a config item.",
+  description: "Set semantic impression/click/attend event definitions of a config item.",
   flags: [
     { name: "project-id", type: "number", required: true, alias: "p", desc: "Numeric project ID." },
     { name: "config-id", type: "string", required: true, desc: "Config item ID." },
-    { name: "impression-event-qp", type: "string", required: false, desc: "Impression event QP JSON." },
-    { name: "click-event-qp", type: "string", required: false, desc: "Click event QP JSON." },
-    { name: "attend-event-qp", type: "string", required: false, desc: "Attend event QP JSON." }
+    { name: "impression-event-definition", type: "json", required: false, desc: "Semantic impression event definition." },
+    { name: "click-event-definition", type: "json", required: false, desc: "Semantic click event definition." },
+    { name: "attend-event-definition", type: "json", required: false, desc: "Semantic attend event definition." }
   ],
   risk: "write",
+  validate: (ctx) => {
+    for (const name of [
+      "impression-event-definition",
+      "click-event-definition",
+      "attend-event-definition"
+    ]) {
+      const definition = ctx.json(name);
+      if (definition !== void 0) validateSemanticEventDefinition(definition, `--${name}`);
+    }
+  },
   buildInput: (ctx) => ({
     project_id: ctx.num("project-id"),
     config_id: ctx.str("config-id"),
-    impression_event_qp: ctx.str("impression-event-qp") || void 0,
-    click_event_qp: ctx.str("click-event-qp") || void 0,
-    attend_event_qp: ctx.str("attend-event-qp") || void 0
+    impression_event_definition: ctx.json("impression-event-definition") || void 0,
+    click_event_definition: ctx.json("click-event-definition") || void 0,
+    attend_event_definition: ctx.json("attend-event-definition") || void 0
   })
 });
 
@@ -1903,13 +2218,17 @@ var strategyCreate = createEngageSceneCapabilityCommand({
       name: "payload",
       type: "json",
       required: true,
-      desc: "ConfigStrategyAddDTO JSON body (configId, templateId, strategyName, templateParamConfig, ...)."
+      desc: "ConfigStrategyAddDTO JSON body. Custom audiences use definitionRequest."
     }
   ],
   risk: "write",
+  validate: (ctx) => {
+    const payload = readRequiredJsonObject(ctx, "payload");
+    validateEmbeddedSemanticDefinitions(payload, "--payload");
+  },
   buildInput: (ctx) => ({
     project_id: ctx.num("project-id"),
-    payload: ctx.json("payload")
+    payload: readRequiredJsonObject(ctx, "payload")
   })
 });
 
@@ -2002,13 +2321,17 @@ var strategyUpdate = createEngageSceneCapabilityCommand({
       name: "payload",
       type: "json",
       required: true,
-      desc: "ConfigStrategyModifyDTO JSON body (strategyUuid + fields to modify)."
+      desc: "ConfigStrategyModifyDTO JSON body including strategyUuid. Custom audiences use definitionRequest."
     }
   ],
   risk: "write",
+  validate: (ctx) => {
+    const payload = readRequiredJsonObject(ctx, "payload");
+    validateEmbeddedSemanticDefinitions(payload, "--payload");
+  },
   buildInput: (ctx) => ({
     project_id: ctx.num("project-id"),
-    payload: ctx.json("payload")
+    payload: readRequiredJsonObject(ctx, "payload")
   })
 });
 
@@ -2038,10 +2361,10 @@ var strategyPredict = createEngageSceneCapabilityCommand({
   flags: [
     { name: "project-id", type: "number", required: true, alias: "p", desc: "Numeric project ID." },
     {
-      name: "qp",
-      type: "string",
+      name: "definition-request",
+      type: "json",
       required: true,
-      desc: "Mix QP JSON string (same as targetClusterQp on the strategy)."
+      desc: "Semantic audience definition request."
     },
     {
       name: "zone-offset",
@@ -2063,9 +2386,15 @@ var strategyPredict = createEngageSceneCapabilityCommand({
     }
   ],
   risk: "read",
+  validate: (ctx) => {
+    validateSemanticAudienceDefinition(
+      readRequiredJsonObject(ctx, "definition-request"),
+      "--definition-request"
+    );
+  },
   buildInput: (ctx) => ({
     project_id: ctx.num("project-id"),
-    qp: ctx.str("qp"),
+    definition_request: readRequiredJsonObject(ctx, "definition-request"),
     zone_offset: ctx.num("zone-offset"),
     ...ctx.str("strategy-uuid") ? { strategy_uuid: ctx.str("strategy-uuid") } : {},
     ...ctx.str("request-id") ? { request_id: ctx.str("request-id") } : {}
@@ -2448,6 +2777,25 @@ var activityInfoList = createEngageActivityCapabilityCommand({
   })
 });
 
+// src/commands/te-engage/engage-activity/approval/submit.ts
+var approvalSubmit = createEngageActivityCapabilityCommand({
+  resource: "approval",
+  command: "submit",
+  capabilityId: "engage-activity.approval.submit",
+  description: "Submit an activity for approval.",
+  flags: [
+    { name: "project-id", type: "number", required: true, alias: "p", desc: "Numeric project ID." },
+    { name: "activity-id", type: "string", required: true, desc: "Activity ID." },
+    { name: "reason", type: "string", required: false, desc: "Optional submit note." }
+  ],
+  risk: "write",
+  buildInput: (ctx) => ({
+    project_id: ctx.num("project-id"),
+    activity_id: ctx.str("activity-id"),
+    reason: ctx.str("reason") || void 0
+  })
+});
+
 // src/commands/te-engage/engage-activity/approval/approve.ts
 var approvalApprove = createEngageActivityCapabilityCommand({
   resource: "approval",
@@ -2505,6 +2853,199 @@ var approvalCancel = createEngageActivityCapabilityCommand({
   })
 });
 
+// src/commands/te-engage/engage-activity/payload-validation.ts
+var TOPIC_TASK_OVERRIDE_FIELDS = [
+  "clusterKey",
+  "triggerDefinition",
+  "triggerRule",
+  "triggerType",
+  "triggerTime",
+  "triggerCrontab",
+  "startDate",
+  "endDate",
+  "triggerTimeStrategy",
+  "tzOffset",
+  "channelType",
+  "channelId",
+  "frequencyLimits",
+  "enableChannelTouchLimits",
+  "channelTouchLimitsRuleDef",
+  "whitelistList",
+  "expConfig"
+];
+var TOPIC_TASK_EXCLUSION_FIELDS = /* @__PURE__ */ new Set([
+  "clusterOutFilters",
+  "totalOutCFilter",
+  "exclude",
+  "excludes"
+]);
+function validateStandaloneActivityPayload(value) {
+  const payload = requireObject(value);
+  validateEmbeddedSemanticDefinitions(payload, "payload");
+  validateTriggerType(payload.triggerType, "triggerType");
+  validateScheduleFields(payload);
+  validateExperiment(payload.expConfig, "expConfig");
+  validateSingleContentGroup(payload.groupContentList, "groupContentList");
+  if (payload.triggerTimeStrategy !== "fixed_time_zone") {
+    fail(
+      "Activity tasks must use triggerTimeStrategy=fixed_time_zone.",
+      "ACTIVITY_TRIGGER_TIME_STRATEGY_UNSUPPORTED",
+      "triggerTimeStrategy",
+      "Use the parent activity timezone. User timezone and user active time are not supported."
+    );
+  }
+  if (typeof payload.tzOffset !== "number" || !Number.isFinite(payload.tzOffset)) {
+    fail(
+      "tzOffset is required for a standalone activity task.",
+      "ACTIVITY_TIMEZONE_REQUIRED",
+      "tzOffset",
+      "Read the parent activity and copy its tzOffset exactly."
+    );
+  }
+}
+function validateActivityTopicPayload(value) {
+  const payload = requireObject(value);
+  validateEmbeddedSemanticDefinitions(payload, "payload");
+  validateTriggerType(payload.triggerType, "triggerType");
+  validateScheduleFields(payload);
+  validateExperiment(payload.expConfig, "expConfig");
+  for (const listField of ["tasks", "modifyTaskList", "addTaskList"]) {
+    const taskList2 = payload[listField];
+    if (!Array.isArray(taskList2)) continue;
+    taskList2.forEach((taskValue, index) => {
+      const task = requireObject(taskValue, `${listField}[${index}]`);
+      if (hasValue(task.targetClusterType) && task.targetClusterType !== 1) {
+        fail(
+          `${listField}[${index}].targetClusterType must be 1 (custom) for a topic task.`,
+          "TOPIC_TASK_OVERRIDE_UNSUPPORTED",
+          `${listField}[${index}].targetClusterType`,
+          "Topic tasks always use the canonical custom audience mode and may only add an inclusion-only definitionRequest."
+        );
+      }
+      for (const field of TOPIC_TASK_OVERRIDE_FIELDS) {
+        if (hasValue(task[field])) {
+          fail(
+            `${listField}[${index}].${field} is not configurable for a topic task.`,
+            "TOPIC_TASK_OVERRIDE_UNSUPPORTED",
+            `${listField}[${index}].${field}`,
+            "Topic tasks inherit schedule, channel, frequency, whitelist, and experiment settings from the topic."
+          );
+        }
+      }
+      if (containsAnyKey(task.definitionRequest, TOPIC_TASK_EXCLUSION_FIELDS)) {
+        fail(
+          `${listField}[${index}].definitionRequest must be an inclusion-only custom audience.`,
+          "TOPIC_TASK_AUDIENCE_EXCLUSION_UNSUPPORTED",
+          `${listField}[${index}].definitionRequest`,
+          "Remove exclusion filters; topic tasks may only refine the shared topic audience with inclusion conditions."
+        );
+      }
+      validateSingleContentGroup(
+        task.groupContentList,
+        `${listField}[${index}].groupContentList`
+      );
+    });
+  }
+}
+function validateTriggerType(value, field) {
+  if (value === 0 || value === 1) return;
+  fail(
+    `${field} only supports 0 (schedule single) or 1 (schedule repeat) for activities.`,
+    "ACTIVITY_TRIGGER_TYPE_UNSUPPORTED",
+    field,
+    "Use engage-task for manual, event-triggered, or other triggered tasks."
+  );
+}
+function validateScheduleFields(payload) {
+  if (payload.triggerType === 0 && !hasValue(payload.triggerTime)) {
+    fail(
+      "triggerTime is required when triggerType=0.",
+      "TRIGGER_TIME_REQUIRED",
+      "triggerTime",
+      "Use yyyy-MM-dd HH:mm in the parent activity timezone."
+    );
+  }
+  if (payload.triggerType === 1) {
+    for (const field of ["startDate", "endDate", "triggerCrontab"]) {
+      if (!hasValue(payload[field])) {
+        fail(
+          `${field} is required when triggerType=1.`,
+          "REPEAT_SCHEDULE_REQUIRED",
+          field,
+          "Provide the complete repeated schedule inside the parent activity period."
+        );
+      }
+    }
+  }
+}
+function validateExperiment(value, field) {
+  if (value === void 0 || value === null) return;
+  if (!isObject2(value)) {
+    fail(
+      `${field} must be omitted or set to {"enableExp":false}.`,
+      "ACTIVITY_EXPERIMENT_UNSUPPORTED",
+      field,
+      "A/B and horse-race experiments are not supported for activity tasks."
+    );
+  }
+  for (const [key, item] of Object.entries(value)) {
+    if (key === "enableExp" && item === false) continue;
+    if (hasValue(item)) {
+      fail(
+        `${field} must not enable or configure an experiment.`,
+        "ACTIVITY_EXPERIMENT_UNSUPPORTED",
+        field,
+        "Remove experiment groups and use exactly one non-experiment content group."
+      );
+    }
+  }
+}
+function validateSingleContentGroup(value, field) {
+  if (Array.isArray(value) && value.length !== 1) {
+    fail(
+      `${field} must contain exactly one non-experiment content group.`,
+      "ACTIVITY_CONTENT_GROUPS_UNSUPPORTED",
+      field,
+      "Keep language variants inside the single group contentList."
+    );
+  }
+}
+function requireObject(value, field = "payload") {
+  if (!isObject2(value)) {
+    fail(
+      `${field} must be a JSON object.`,
+      "ACTIVITY_PAYLOAD_INVALID",
+      field,
+      "Pass a native camelCase activity task or topic payload."
+    );
+  }
+  return value;
+}
+function containsAnyKey(value, keys) {
+  if (Array.isArray(value)) return value.some((item) => containsAnyKey(item, keys));
+  if (!isObject2(value)) return false;
+  return Object.entries(value).some(
+    ([key, item]) => keys.has(key) && hasValue(item) || containsAnyKey(item, keys)
+  );
+}
+function hasValue(value) {
+  if (value === void 0 || value === null) return false;
+  if (typeof value === "string") return value.trim().length > 0;
+  if (Array.isArray(value)) return value.length > 0;
+  if (isObject2(value)) return Object.keys(value).length > 0;
+  return true;
+}
+function isObject2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function fail(message, code, field, hint) {
+  throw new CliValidationError(message, {
+    code,
+    hint,
+    location: { field }
+  });
+}
+
 // src/commands/te-engage/engage-activity/topic/create.ts
 var topicCreate = createEngageActivityCapabilityCommand({
   resource: "topic",
@@ -2517,10 +3058,11 @@ var topicCreate = createEngageActivityCapabilityCommand({
       name: "payload",
       type: "json",
       required: true,
-      desc: "TopicAddDTO JSON body. Required: activityId, topicName, targetClusterType, channelType, channelId, triggerType, enableChannelTouchLimits, frequencyLimits, tasks. When targetClusterType=2 use topicClusterKey (not clusterKey); when =1 use topicQp. Task items use taskQp/clusterKey."
+      desc: "TopicAddDTO JSON body. Use triggerType 0/1 and no experiment. Topic tasks may only add an inclusion-only definitionRequest and inherit shared settings."
     }
   ],
   risk: "write",
+  validate: (ctx) => validateActivityTopicPayload(ctx.json("payload")),
   buildInput: (ctx) => ({
     project_id: ctx.num("project-id"),
     payload: ctx.json("payload")
@@ -2539,10 +3081,11 @@ var topicUpdate = createEngageActivityCapabilityCommand({
       name: "payload",
       type: "json",
       required: true,
-      desc: "TopicModifyReq JSON body (topicId + TopicAddDTO fields + modifyTaskList/addTaskList/delTaskIdList). Same audience rules: topicClusterKey for targetClusterType=2, topicQp for =1."
+      desc: "TopicModifyReq JSON body. Use triggerType 0/1 and no experiment. Topic tasks may retain targetClusterType=1 from get, add an inclusion-only definitionRequest, and otherwise inherit shared settings."
     }
   ],
   risk: "write",
+  validate: (ctx) => validateActivityTopicPayload(ctx.json("payload")),
   buildInput: (ctx) => ({
     project_id: ctx.num("project-id"),
     payload: ctx.json("payload")
@@ -2714,10 +3257,11 @@ var taskCreate = createEngageActivityCapabilityCommand({
       name: "payload",
       type: "json",
       required: true,
-      desc: "OperationTaskOpDTO JSON body (taskName, channelType, channelId, groupContentList, targetClusterType, triggerType, completionIndicatorDef, frequencyLimits, groupId, activityId, triggerTimeStrategy, ...). Set activityId; leave topicId empty for a standalone task."
+      desc: "OperationTaskOpDTO JSON body. Use triggerType 0/1, fixed_time_zone, no experiment, and one content group. Custom audiences use definitionRequest. Set activityId and leave topicId empty."
     }
   ],
   risk: "write",
+  validate: (ctx) => validateStandaloneActivityPayload(ctx.json("payload")),
   buildInput: (ctx) => ({
     project_id: ctx.num("project-id"),
     payload: ctx.json("payload")
@@ -2732,9 +3276,15 @@ var taskUpdate = createEngageActivityCapabilityCommand({
   description: "Edit a standalone task from an OperationTaskOpDTO payload (includes taskId).",
   flags: [
     { name: "project-id", type: "number", required: true, alias: "p", desc: "Numeric project ID." },
-    { name: "payload", type: "json", required: true, desc: "OperationTaskOpDTO JSON body including taskId." }
+    {
+      name: "payload",
+      type: "json",
+      required: true,
+      desc: "OperationTaskOpDTO JSON body including taskId. Use triggerType 0/1, fixed_time_zone, no experiment, and one content group."
+    }
   ],
   risk: "write",
+  validate: (ctx) => validateStandaloneActivityPayload(ctx.json("payload")),
   buildInput: (ctx) => ({
     project_id: ctx.num("project-id"),
     payload: ctx.json("payload")
@@ -2771,7 +3321,7 @@ var commands4 = [
   activityEnd,
   activityStats,
   activityInfoList,
-  // approvalSubmit,
+  approvalSubmit,
   approvalApprove,
   approvalReject,
   approvalCancel,
@@ -3213,6 +3763,49 @@ var taskModifyGroup = createEngageTaskCapabilityCommand({
   })
 });
 
+// src/commands/te-engage/engage-task/task/submit-approval.ts
+function buildSubmitApprovalInput(ctx) {
+  const taskId = ctx.str("task-id").trim();
+  const request = ctx.json("request");
+  if (taskId === "" === (request === void 0)) {
+    throw new Error("Exactly one of --task-id or --request is required");
+  }
+  if (request !== void 0 && (request === null || typeof request !== "object" || Array.isArray(request))) {
+    throw new Error("Flag --request must be a JSON object");
+  }
+  return {
+    project_id: ctx.num("project-id"),
+    ...taskId !== "" && { task_id: taskId },
+    ...request !== void 0 && { request }
+  };
+}
+var taskSubmitApproval = createEngageTaskCapabilityCommand({
+  resource: "task",
+  command: "submit-approval",
+  capabilityId: "engage-task.task.submit-approval",
+  description: "Save a draft task and submit it for approval.",
+  flags: [
+    { name: "project-id", type: "number", required: true, alias: "p", desc: "Numeric project ID." },
+    {
+      name: "task-id",
+      type: "string",
+      required: false,
+      desc: "Existing draft task ID. Exactly one of --task-id or --request is required."
+    },
+    {
+      name: "request",
+      type: "json",
+      required: false,
+      desc: "Legacy ApprovalSaveAndSubmitDTO JSON. Exactly one of --task-id or --request is required."
+    }
+  ],
+  risk: "write",
+  validate: (ctx) => {
+    buildSubmitApprovalInput(ctx);
+  },
+  buildInput: buildSubmitApprovalInput
+});
+
 // src/commands/te-engage/engage-task/task/build-save-guide.ts
 var taskBuildSaveGuide = createEngageTaskCapabilityCommand({
   resource: "task",
@@ -3290,11 +3883,16 @@ var taskSave = createEngageTaskCapabilityCommand({
   description: "Create a task draft, or update an existing draft/paused task.",
   flags: [
     { name: "project-id", type: "number", required: true, alias: "p", desc: "Numeric project ID." },
-    { name: "req", type: "json", required: true, desc: "Task save request JSON object." }
+    {
+      name: "req",
+      type: "json",
+      required: true,
+      desc: "Task save JSON; custom audiences use targetConfig.definitionRequest."
+    }
   ],
   risk: "write",
   validate: (ctx) => {
-    readRequiredJsonObject(ctx, "req");
+    validateEmbeddedSemanticDefinitions(readRequiredJsonObject(ctx, "req"), "--req");
   },
   buildInput: (ctx) => ({ project_id: ctx.num("project-id"), req: readRequiredJsonObject(ctx, "req") })
 });
@@ -3339,8 +3937,8 @@ var commands6 = [
   segmentListRename,
   segmentListSetVisibility,
   taskDelete,
-  taskModifyGroup
-  // taskSubmitApproval,
+  taskModifyGroup,
+  taskSubmitApproval
 ];
 var engage_task_default = commands6;