@lexq/cli 1.1.5 → 1.1.7

package/dist/index.js

@@ -608,7 +608,10 @@ ${data.length} total`);
         The remaining traffic continues to the current live version.
       `
   );
-  abTest.command("start").description("Start an A/B test").requiredOption("--group-id <groupId>", "Policy group ID").requiredOption("--version-id <versionId>", "Challenger version ID").requiredOption(
+  abTest.command("start").description("Start an A/B test").requiredOption("--group-id <groupId>", "Policy group ID").requiredOption(
+    "--version-id <versionId>",
+    "Challenger version ID (a published version of this group)"
+  ).requiredOption(
     "--traffic-rate <rate>",
     `Traffic rate for challenger (${MIN_TRAFFIC_RATE}-${MAX_TRAFFIC_RATE})`
   ).addHelpText(
@@ -1234,6 +1237,46 @@ ${data.length} total`);
 import "commander";
 import dedent6 from "dedent";
 
+// src/lib/value-domain-warning.ts
+function formatValueDomainMismatchWarning(meta) {
+  const mismatch = meta?.valueDomainMismatch;
+  if (!mismatch || !Array.isArray(mismatch.versions) || mismatch.versions.length === 0) return null;
+  const n = mismatch.totalRuleCount;
+  const subject = n === 1 ? "1 rule compares" : `${n} rules compare`;
+  const lines = [
+    `\u26A0 ${subject} ${mismatch.factKey} with values the new value domain does not accept. The update was still saved.`
+  ];
+  for (const version of mismatch.versions) {
+    lines.push(...versionLines(mismatch.factKey, version));
+  }
+  return lines.join("\n");
+}
+function versionLines(factKey, version) {
+  const draft = version.versionStatus === "DRAFT";
+  const lines = [
+    `  ${quoted(version.groupName)} v${version.versionNo}, ${draft ? "draft" : "deployed"} (groupId ${version.groupId}, versionId ${version.versionId})`,
+    draft ? "    Dry runs of this draft already reject calls that send these values (P-052), and live calls will too once it is published and deployed. Saving one of these rules again is refused (P-051) until each listed condition is edited or removed; first check whether each one is still needed." : "    Calls to it are checked against the fact definitions captured when it was published, so this change does not affect them. A version cloned from it carries these rules; fix them in the clone before publishing it."
+  ];
+  for (const rule of version.rules) {
+    const conditions = rule.conditions.map(
+      (c) => `${factKey} ${c.operator} ${escapeUnsafe(stringifyJson(c.value) ?? String(c.value))}`
+    ).join("; ");
+    lines.push(`    \u2022 ${quoted(rule.ruleName)} (ruleId ${rule.ruleId}): ${conditions}`);
+  }
+  const hidden = version.ruleCount - version.rules.length;
+  if (hidden > 0) {
+    lines.push(`    \u2026 and ${hidden} more rule${hidden === 1 ? "" : "s"} in this version.`);
+  }
+  return lines;
+}
+function quoted(name) {
+  return escapeUnsafe(stringifyJson(String(name)) ?? '""');
+}
+var UNSAFE = /[\u007f-\u009f\u061c\u200e\u200f\u2028\u2029\u202a-\u202e\u2066-\u2069]/g;
+function escapeUnsafe(json) {
+  return json.replace(UNSAFE, (c) => `\\u${c.charCodeAt(0).toString(16).padStart(4, "0")}`);
+}
+
 // src/lib/export.ts
 import { writeFileSync as writeFileSync2 } from "fs";
 
@@ -1420,8 +1463,8 @@ ${data.length} unregistered`);
                       the rule editor into a dropdown instead of a free text box.
                       STRING types take --allowed-values. NUMBER types take all three.
                       BOOLEAN takes none — it has only two values to begin with.
-                      For list types the constraint applies to each element.
-                      Leave them out for no constraint, which is how facts behaved before.
+                      For list types the value domain applies to each element.
+                      Leave them out for no value domain, which is how facts behaved before.
       `
   ).action(async (opts) => {
     try {
@@ -1440,7 +1483,7 @@ ${data.length} unregistered`);
       process.exit(1);
     }
   });
-  facts.command("update").description("Update a fact definition").requiredOption("--id <factId>", "Fact definition ID").option("--name <n>", "Display name").option("--description <desc>", "Description").option("--required", "Mark as required").option("--no-required", "Mark as not required").option("--pii", "Mark as PII (enables masking)").option("--no-pii", "Unmark as PII (disables masking \u2014 value becomes visible)").option("--type <type>", "Value type: STRING, NUMBER, BOOLEAN, LIST_STRING, LIST_NUMBER").option("--allowed-values <csv>", "Comma-separated list of accepted values").option("--min <number>", "Lower bound, inclusive (numeric types only)").option("--max <number>", "Upper bound, inclusive (numeric types only)").option("--clear-value-domain", "Remove the value constraint entirely").option("--json <body>", "Full request body as JSON (overrides other options)").addHelpText(
+  facts.command("update").description("Update a fact definition").requiredOption("--id <factId>", "Fact definition ID").option("--name <n>", "Display name").option("--description <desc>", 'Description (pass "" to remove it)').option("--required", "Mark as required").option("--no-required", "Mark as not required").option("--pii", "Mark as PII (enables masking)").option("--no-pii", "Unmark as PII (disables masking \u2014 value becomes visible)").option("--type <type>", "Value type: STRING, NUMBER, BOOLEAN, LIST_STRING, LIST_NUMBER").option("--allowed-values <csv>", "Comma-separated list of accepted values").option("--min <number>", "Lower bound, inclusive (numeric types only)").option("--max <number>", "Upper bound, inclusive (numeric types only)").option("--clear-value-domain", "Remove the value domain entirely").option("--json <body>", "Full request body as JSON (overrides other options)").addHelpText(
     "after",
     dedent6`
 
@@ -1453,10 +1496,11 @@ ${data.length} unregistered`);
           $ lexq facts update --id <factId> --clear-value-domain
 
         Only the flags you pass are changed. Leaving out --allowed-values, --min, and --max
-        leaves the constraint alone; --clear-value-domain removes it.
+        leaves the value domain alone; --clear-value-domain removes it.
 
-        Narrowing a constraint does not rewrite rules that already reference this fact. They keep
-        working, and the next time one is saved it is judged against the new constraint.
+        Narrowing the value domain never blocks the update and does not rewrite rules. When rules
+        compare this fact with a value the new value domain excludes, a warning on stderr lists them
+        by version: drafts and the versions currently deployed.
 
         Pass --type when the accepted values are numbers and you are not also naming the type,
         so "10" is sent as a number rather than a string. --json settles it either way.
@@ -1465,14 +1509,22 @@ ${data.length} unregistered`);
     try {
       const globalOpts = program.opts();
       const body = opts.json ? JSON.parse(opts.json) : buildUpdateBody2(opts);
-      const data = await apiRequest("PUT", `schema/facts/${opts.id}`, {
-        apiKey: globalOpts.apiKey,
-        baseUrl: globalOpts.baseUrl,
-        dryRun: globalOpts.dryRun,
-        verbose: globalOpts.verbose,
-        body
-      });
+      const { data, meta } = await apiRequestWithMeta(
+        "PUT",
+        `schema/facts/${opts.id}`,
+        {
+          apiKey: globalOpts.apiKey,
+          baseUrl: globalOpts.baseUrl,
+          dryRun: globalOpts.dryRun,
+          verbose: globalOpts.verbose,
+          body
+        }
+      );
       printJson(data);
+      const warning = formatValueDomainMismatchWarning(meta);
+      if (warning) console.error(`
+${warning}
+`);
     } catch (error) {
       printError(error);
       process.exit(1);
@@ -1583,7 +1635,7 @@ function buildUpdateBody2(opts) {
   if (opts.description !== void 0) body.description = opts.description;
   if (opts.type) body.type = opts.type;
   if (typeof opts.required === "boolean") body.isRequired = opts.required;
-  if (typeof opts.isPii === "boolean") body.isPii = opts.isPii;
+  if (typeof opts.pii === "boolean") body.isPii = opts.pii;
   if (opts.clearValueDomain === true) {
     if (hasDomainFlag(opts)) {
       throw new Error(
@@ -3531,6 +3583,8 @@ function createCallApiFromConfig() {
       ];
       const warning = formatUnregisteredFactWarning(meta);
       if (warning) content.push({ type: "text", text: warning });
+      const domainWarning = formatValueDomainMismatchWarning(meta);
+      if (domainWarning) content.push({ type: "text", text: domainWarning });
       return { content };
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
@@ -3709,10 +3763,10 @@ function registerGroupTools(server, callApi) {
     {
       title: "Start A/B Test",
       annotations: { readOnlyHint: false, destructiveHint: false },
-      description: "Start an A/B test on a policy group. Requires a challenger version ID and traffic rate. The split is computed from context.trafficKey on each execution request; requests that omit it never reach the challenger and the test stays at 0%.",
+      description: "Start an A/B test on a policy group. Requires a challenger version ID and traffic rate. The challenger must be a published version of the same group; a version from another group is rejected with P-016. The split is computed from context.trafficKey on each execution request; requests that omit it never reach the challenger and the test stays at 0%.",
       inputSchema: z2.object({
         groupId: z2.string().uuid().describe("Policy group ID"),
-        testVersionId: z2.string().uuid().describe("Challenger version ID to test"),
+        testVersionId: z2.string().uuid().describe("Challenger version ID. Must be a published version of this group"),
         trafficRate: z2.number().int().min(1).max(99).describe("Traffic percentage routed to challenger (1-99)")
       })
     },
@@ -4100,12 +4154,12 @@ function registerFactTools(server, callApi) {
         ),
         valueDomain: z5.object({
           allowedValues: z5.array(z5.union([z5.string(), z5.number()])).optional().describe(
-            "Accepted values. For list types the constraint applies to each element, not to the list as a whole."
+            "Accepted values. For list types the value domain applies to each element, not to the list as a whole."
           ),
           min: z5.number().optional().describe("Lower bound, inclusive. Numeric types only."),
           max: z5.number().optional().describe("Upper bound, inclusive. Numeric types only.")
         }).optional().describe(
-          "Which values this fact accepts. Omit for no constraint. STRING and LIST_STRING take allowedValues only; NUMBER and LIST_NUMBER take all three; BOOLEAN takes none. Declaring it lets the rule editor offer a dropdown and rejects a rule literal that could never match."
+          "Which values this fact accepts. Omit for no value domain. STRING and LIST_STRING take allowedValues only; NUMBER and LIST_NUMBER take all three; BOOLEAN takes none. Declaring it lets the rule editor offer a dropdown and rejects a rule literal that could never match."
         )
       })
     },
@@ -4120,7 +4174,7 @@ function registerFactTools(server, callApi) {
       inputSchema: z5.object({
         factId: z5.string().uuid().describe("Fact definition ID"),
         name: z5.string().optional().describe("Display name"),
-        description: z5.string().optional().describe("Description"),
+        description: z5.string().optional().describe('Description. Send "" to remove it.'),
         type: z5.enum(VALUE_TYPES).optional().describe(
           "Value type. Omit to leave it unchanged. Changing it fails with FD-007 while any rule outside a deleted group references the fact."
         ),
@@ -4128,12 +4182,12 @@ function registerFactTools(server, callApi) {
         isPii: z5.boolean().optional().describe("PII flag \u2014 enables/disables masking (changeable even on system facts)"),
         valueDomain: z5.object({
           allowedValues: z5.array(z5.union([z5.string(), z5.number()])).optional().describe(
-            "Accepted values. For list types the constraint applies to each element, not to the list as a whole."
+            "Accepted values. For list types the value domain applies to each element, not to the list as a whole."
           ),
           min: z5.number().optional().describe("Lower bound, inclusive. Numeric types only."),
           max: z5.number().optional().describe("Upper bound, inclusive. Numeric types only.")
         }).optional().describe(
-          "Which values this fact accepts. Three states: omit the field to leave the constraint alone, send {} to remove it, or send a populated object to replace it. Narrowing it does not rewrite rules that already reference this fact \u2014 they keep working, and the next save is judged against the new constraint."
+          "Which values this fact accepts. Three states: omit the field to leave the value domain alone, send {} to remove it, or send a populated object to replace it. Narrowing it never blocks the update and does not rewrite rules. When rules compare this fact with a value the new value domain excludes, the result ends with a warning that lists them by version: drafts and the versions currently deployed."
         )
       })
     },
@@ -5022,7 +5076,7 @@ function registerDomainTemplateTools(server, callApi) {
     {
       title: "Preview Domain Template",
       annotations: { readOnlyHint: true },
-      description: "Preview exactly what a domain template will provision before applying it: the fact definitions it registers (an input with a constraint carries its allowed values or range), the sample rules it creates with a description of each, and an apply plan. This is a read-only dry run; nothing is created. factConflicts lists keys this tenant already has with a different type, or with different allowed values or a different range on an input fact. While it is not empty, apply fails with P-061 and creates nothing: delete those facts or change them to match the template, then apply. plan is null for a template that cannot be applied yet.",
+      description: "Preview exactly what a domain template will provision before applying it: the fact definitions it registers (an input with a value domain carries its allowed values or range), the sample rules it creates with a description of each, and an apply plan. This is a read-only dry run; nothing is created. factConflicts lists keys this tenant already has with a different type, or with different allowed values or a different range on an input fact. While it is not empty, apply fails with P-061 and creates nothing: delete those facts or change them to match the template, then apply. plan is null for a template that cannot be applied yet.",
       inputSchema: z14.object({
         template: z14.string().describe(
           "Domain template key (e.g. ECOMMERCE). Use lexq_domain_templates_list to see the keys."

package/dist/mcp/register.d.ts

@@ -37,6 +37,30 @@ declare function paginationParams(page?: number, size?: number): Record<string,
  */
 declare function formatUnregisteredFactWarning(meta: unknown): string | null;
 
+/**
+ * Builds the warning text for meta.valueDomainMismatch, which a fact update returns when its new
+ * value domain excludes values that existing rules compare against. Returns null when the
+ * response carries none.
+ *
+ * The CLI and the MCP server print the same text: `lexq facts update` writes it to stderr and the
+ * stdio MCP server appends it to the tool result. It is exported from `@lexq/cli/mcp` so a server
+ * that hosts these tools can append it too. The ids are included so an agent can go straight to
+ * the rule.
+ *
+ * The advice depends on the version. A draft is checked against the new value domain already: its
+ * dry runs reject these values now, and live calls will too once it is published and deployed. A
+ * deployed version keeps the fact definitions captured when it was published, so calls to it are
+ * unaffected, but a version cloned from it carries the rule. Values are printed as the rule holds
+ * them; this text does not judge whether a condition became always true or always false, so it
+ * does not say whether to change a value or remove the condition.
+ *
+ * Group and rule names and condition values are written by users, so they are printed as JSON
+ * strings with control characters (C0 and C1), line and paragraph separators, and text-direction
+ * controls escaped. They cannot drive the terminal, break the layout with a new line, reorder the
+ * text around them, or pass as part of the warning an agent reads.
+ */
+declare function formatValueDomainMismatchWarning(meta: unknown): string | null;
+
 declare class ApiError extends Error {
     readonly statusCode: number;
     readonly errorCode: string | null;
@@ -73,4 +97,4 @@ declare function registerAllTools(server: McpServer, callApi: CallApi): void;
  */
 declare const SERVER_INFO: Omit<Implementation, 'version'>;
 
-export { ApiError, type CallApi, type McpToolResult, SERVER_INFO, formatUnregisteredFactWarning, isLosslessNumber, paginationParams, parseJson, registerAllTools, stringifyJson };
+export { ApiError, type CallApi, type McpToolResult, SERVER_INFO, formatUnregisteredFactWarning, formatValueDomainMismatchWarning, isLosslessNumber, paginationParams, parseJson, registerAllTools, stringifyJson };

package/dist/mcp/register.js

@@ -182,10 +182,10 @@ function registerGroupTools(server, callApi) {
     {
       title: "Start A/B Test",
       annotations: { readOnlyHint: false, destructiveHint: false },
-      description: "Start an A/B test on a policy group. Requires a challenger version ID and traffic rate. The split is computed from context.trafficKey on each execution request; requests that omit it never reach the challenger and the test stays at 0%.",
+      description: "Start an A/B test on a policy group. Requires a challenger version ID and traffic rate. The challenger must be a published version of the same group; a version from another group is rejected with P-016. The split is computed from context.trafficKey on each execution request; requests that omit it never reach the challenger and the test stays at 0%.",
       inputSchema: z2.object({
         groupId: z2.string().uuid().describe("Policy group ID"),
-        testVersionId: z2.string().uuid().describe("Challenger version ID to test"),
+        testVersionId: z2.string().uuid().describe("Challenger version ID. Must be a published version of this group"),
         trafficRate: z2.number().int().min(1).max(99).describe("Traffic percentage routed to challenger (1-99)")
       })
     },
@@ -253,6 +253,46 @@ var ApiError = class extends Error {
   errorCode;
 };
 
+// src/lib/value-domain-warning.ts
+function formatValueDomainMismatchWarning(meta) {
+  const mismatch = meta?.valueDomainMismatch;
+  if (!mismatch || !Array.isArray(mismatch.versions) || mismatch.versions.length === 0) return null;
+  const n = mismatch.totalRuleCount;
+  const subject = n === 1 ? "1 rule compares" : `${n} rules compare`;
+  const lines = [
+    `\u26A0 ${subject} ${mismatch.factKey} with values the new value domain does not accept. The update was still saved.`
+  ];
+  for (const version of mismatch.versions) {
+    lines.push(...versionLines(mismatch.factKey, version));
+  }
+  return lines.join("\n");
+}
+function versionLines(factKey, version) {
+  const draft = version.versionStatus === "DRAFT";
+  const lines = [
+    `  ${quoted(version.groupName)} v${version.versionNo}, ${draft ? "draft" : "deployed"} (groupId ${version.groupId}, versionId ${version.versionId})`,
+    draft ? "    Dry runs of this draft already reject calls that send these values (P-052), and live calls will too once it is published and deployed. Saving one of these rules again is refused (P-051) until each listed condition is edited or removed; first check whether each one is still needed." : "    Calls to it are checked against the fact definitions captured when it was published, so this change does not affect them. A version cloned from it carries these rules; fix them in the clone before publishing it."
+  ];
+  for (const rule of version.rules) {
+    const conditions = rule.conditions.map(
+      (c) => `${factKey} ${c.operator} ${escapeUnsafe(stringifyJson(c.value) ?? String(c.value))}`
+    ).join("; ");
+    lines.push(`    \u2022 ${quoted(rule.ruleName)} (ruleId ${rule.ruleId}): ${conditions}`);
+  }
+  const hidden = version.ruleCount - version.rules.length;
+  if (hidden > 0) {
+    lines.push(`    \u2026 and ${hidden} more rule${hidden === 1 ? "" : "s"} in this version.`);
+  }
+  return lines;
+}
+function quoted(name) {
+  return escapeUnsafe(stringifyJson(String(name)) ?? '""');
+}
+var UNSAFE = /[\u007f-\u009f\u061c\u200e\u200f\u2028\u2029\u202a-\u202e\u2066-\u2069]/g;
+function escapeUnsafe(json) {
+  return json.replace(UNSAFE, (c) => `\\u${c.charCodeAt(0).toString(16).padStart(4, "0")}`);
+}
+
 // src/mcp/tools/_shared.ts
 function paginationParams(page, size) {
   const params = {};
@@ -646,12 +686,12 @@ function registerFactTools(server, callApi) {
         ),
         valueDomain: z5.object({
           allowedValues: z5.array(z5.union([z5.string(), z5.number()])).optional().describe(
-            "Accepted values. For list types the constraint applies to each element, not to the list as a whole."
+            "Accepted values. For list types the value domain applies to each element, not to the list as a whole."
           ),
           min: z5.number().optional().describe("Lower bound, inclusive. Numeric types only."),
           max: z5.number().optional().describe("Upper bound, inclusive. Numeric types only.")
         }).optional().describe(
-          "Which values this fact accepts. Omit for no constraint. STRING and LIST_STRING take allowedValues only; NUMBER and LIST_NUMBER take all three; BOOLEAN takes none. Declaring it lets the rule editor offer a dropdown and rejects a rule literal that could never match."
+          "Which values this fact accepts. Omit for no value domain. STRING and LIST_STRING take allowedValues only; NUMBER and LIST_NUMBER take all three; BOOLEAN takes none. Declaring it lets the rule editor offer a dropdown and rejects a rule literal that could never match."
         )
       })
     },
@@ -666,7 +706,7 @@ function registerFactTools(server, callApi) {
       inputSchema: z5.object({
         factId: z5.string().uuid().describe("Fact definition ID"),
         name: z5.string().optional().describe("Display name"),
-        description: z5.string().optional().describe("Description"),
+        description: z5.string().optional().describe('Description. Send "" to remove it.'),
         type: z5.enum(VALUE_TYPES).optional().describe(
           "Value type. Omit to leave it unchanged. Changing it fails with FD-007 while any rule outside a deleted group references the fact."
         ),
@@ -674,12 +714,12 @@ function registerFactTools(server, callApi) {
         isPii: z5.boolean().optional().describe("PII flag \u2014 enables/disables masking (changeable even on system facts)"),
         valueDomain: z5.object({
           allowedValues: z5.array(z5.union([z5.string(), z5.number()])).optional().describe(
-            "Accepted values. For list types the constraint applies to each element, not to the list as a whole."
+            "Accepted values. For list types the value domain applies to each element, not to the list as a whole."
           ),
           min: z5.number().optional().describe("Lower bound, inclusive. Numeric types only."),
           max: z5.number().optional().describe("Upper bound, inclusive. Numeric types only.")
         }).optional().describe(
-          "Which values this fact accepts. Three states: omit the field to leave the constraint alone, send {} to remove it, or send a populated object to replace it. Narrowing it does not rewrite rules that already reference this fact \u2014 they keep working, and the next save is judged against the new constraint."
+          "Which values this fact accepts. Three states: omit the field to leave the value domain alone, send {} to remove it, or send a populated object to replace it. Narrowing it never blocks the update and does not rewrite rules. When rules compare this fact with a value the new value domain excludes, the result ends with a warning that lists them by version: drafts and the versions currently deployed."
         )
       })
     },
@@ -1568,7 +1608,7 @@ function registerDomainTemplateTools(server, callApi) {
     {
       title: "Preview Domain Template",
       annotations: { readOnlyHint: true },
-      description: "Preview exactly what a domain template will provision before applying it: the fact definitions it registers (an input with a constraint carries its allowed values or range), the sample rules it creates with a description of each, and an apply plan. This is a read-only dry run; nothing is created. factConflicts lists keys this tenant already has with a different type, or with different allowed values or a different range on an input fact. While it is not empty, apply fails with P-061 and creates nothing: delete those facts or change them to match the template, then apply. plan is null for a template that cannot be applied yet.",
+      description: "Preview exactly what a domain template will provision before applying it: the fact definitions it registers (an input with a value domain carries its allowed values or range), the sample rules it creates with a description of each, and an apply plan. This is a read-only dry run; nothing is created. factConflicts lists keys this tenant already has with a different type, or with different allowed values or a different range on an input fact. While it is not empty, apply fails with P-061 and creates nothing: delete those facts or change them to match the template, then apply. plan is null for a template that cannot be applied yet.",
       inputSchema: z14.object({
         template: z14.string().describe(
           "Domain template key (e.g. ECOMMERCE). Use lexq_domain_templates_list to see the keys."
@@ -1621,6 +1661,7 @@ export {
   LosslessNumber,
   SERVER_INFO,
   formatUnregisteredFactWarning,
+  formatValueDomainMismatchWarning,
   isLosslessNumber,
   paginationParams,
   parseJson,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lexq/cli",
-  "version": "1.1.5",
+  "version": "1.1.7",
   "mcpName": "io.lexq/lexq",
   "description": "LexQ CLI — manage policies, simulate rules, and deploy from the terminal. Built for humans and AI agents.",
   "type": "module",
@@ -43,6 +43,7 @@
     "test:export-format": "node tests/export-format.mjs",
     "test:command-options": "node tests/command-options.mjs",
     "test:value-domain": "pnpm build && node tests/value-domain.mjs",
+    "test:fact-update": "pnpm build && node tests/fact-update.mjs",
     "prepublishOnly": "pnpm build",
     "knip": "knip",
     "format": "prettier --write \"src/**/*.ts\"",

package/skills/lexq-groups/SKILL.md

@@ -220,8 +220,9 @@ lexq groups ab-test start --group-id <groupId> --version-id <activeVersionId> --
 
 `--traffic-rate` is the percentage (1–99) of traffic routed to the test version.
 
-The test version must be `ACTIVE` (published) and different from the live version. Starting a test cancels any pending
-scheduled deployment for the group.
+The test version must be a version of the same group, `ACTIVE` (published), and different from the live version. A
+version from another group is rejected with `P-016`. Starting a test cancels any pending scheduled deployment for the
+group.
 
 ### Adjust Traffic