@lexq/cli 1.1.4 → 1.1.6

package/dist/index.js

@@ -1234,6 +1234,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 +1460,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 +1480,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 +1493,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 +1506,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 +1632,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 +3580,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);
@@ -4100,12 +4151,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 +4171,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 +4179,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."
         )
       })
     },
@@ -5012,7 +5063,7 @@ function registerDomainTemplateTools(server, callApi) {
     {
       title: "List Domain Templates",
       annotations: { readOnlyHint: true },
-      description: "List all domain templates. A domain template is a curated, industry-specific starter pack of fact definitions and sample rules (e.g. ECOMMERCE). Each entry reports its key, status (ACTIVE or COMING_SOON), and a summary of what it provisions. Call this before preview or apply to discover which templates can currently be applied.",
+      description: "List all domain templates. A domain template is a starter pack of fact definitions and sample rules for a common decision, such as checkout pricing (ECOMMERCE) or transfer approval (FINTECH). Each entry reports its key, whether it can be applied (isAvailable), and how many facts and sample rules it provisions. Call this before preview or apply to see which templates exist.",
       inputSchema: z14.object({})
     },
     async () => callApi("GET", "domain-templates")
@@ -5022,10 +5073,10 @@ 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, the sample rules it creates, and an apply plan. This is a read-only dry run \u2014 nothing is created. Only ACTIVE templates can be previewed.",
+      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 available keys \u2014 currently only ECOMMERCE is ACTIVE."
+          "Domain template key (e.g. ECOMMERCE). Use lexq_domain_templates_list to see the keys."
         )
       })
     },
@@ -5036,7 +5087,7 @@ function registerDomainTemplateTools(server, callApi) {
     {
       title: "Apply Domain Template",
       annotations: { readOnlyHint: false, destructiveHint: false },
-      description: "Apply a domain template to the current tenant. Creates the template's fact definitions and a new policy group pre-populated with its sample rules as a DRAFT version. Existing facts are skipped \u2014 apply is additive and never overwrites existing schema. Run lexq_domain_templates_preview first to review what will be created. Only ACTIVE templates can be applied.",
+      description: "Apply a domain template to the current tenant. Creates the template's fact definitions and a new policy group pre-populated with its sample rules as a DRAFT version. Apply never overwrites existing schema: a key that already exists with the same definition is kept as it is. Run lexq_domain_templates_preview first. If its factConflicts is not empty, apply fails with P-061 and creates nothing until those facts are deleted or changed to match the template. A template whose isAvailable is false cannot be applied.",
       inputSchema: z14.object({
         template: z14.string().describe("Domain template key to apply (e.g. ECOMMERCE)."),
         customName: z14.string().optional().describe(
@@ -5153,7 +5204,7 @@ function registerDomainTemplateCommands(program) {
           apply     Apply a template to the current tenant
 
         Workflow: list → preview → apply
-        Currently available: ECOMMERCE  (FINTECH, SAAS — coming soon)
+        Run "list" to see every template and whether it can be applied.
       `
   );
   templates.command("list").description("List available domain templates").action(async () => {
@@ -5220,10 +5271,12 @@ function registerDomainTemplateCommands(program) {
     dedent18`
 
         Creates the template's fact definitions and a new DRAFT policy group
-        populated with its sample rules. Existing facts are skipped — apply is
-        additive and never overwrites your schema.
+        populated with its sample rules. A fact that already exists with the
+        same definition is kept as it is, so apply never overwrites your schema.
 
-        Run "preview" first to review what will be created.
+        Run "preview" first to review what will be created. If it lists
+        factConflicts, apply fails with P-061 and creates nothing: delete those
+        facts or change them to match the template first.
 
         Example:
           $ lexq domain-templates apply --template ECOMMERCE

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

@@ -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."
         )
       })
     },
@@ -1558,7 +1598,7 @@ function registerDomainTemplateTools(server, callApi) {
     {
       title: "List Domain Templates",
       annotations: { readOnlyHint: true },
-      description: "List all domain templates. A domain template is a curated, industry-specific starter pack of fact definitions and sample rules (e.g. ECOMMERCE). Each entry reports its key, status (ACTIVE or COMING_SOON), and a summary of what it provisions. Call this before preview or apply to discover which templates can currently be applied.",
+      description: "List all domain templates. A domain template is a starter pack of fact definitions and sample rules for a common decision, such as checkout pricing (ECOMMERCE) or transfer approval (FINTECH). Each entry reports its key, whether it can be applied (isAvailable), and how many facts and sample rules it provisions. Call this before preview or apply to see which templates exist.",
       inputSchema: z14.object({})
     },
     async () => callApi("GET", "domain-templates")
@@ -1568,10 +1608,10 @@ 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, the sample rules it creates, and an apply plan. This is a read-only dry run \u2014 nothing is created. Only ACTIVE templates can be previewed.",
+      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 available keys \u2014 currently only ECOMMERCE is ACTIVE."
+          "Domain template key (e.g. ECOMMERCE). Use lexq_domain_templates_list to see the keys."
         )
       })
     },
@@ -1582,7 +1622,7 @@ function registerDomainTemplateTools(server, callApi) {
     {
       title: "Apply Domain Template",
       annotations: { readOnlyHint: false, destructiveHint: false },
-      description: "Apply a domain template to the current tenant. Creates the template's fact definitions and a new policy group pre-populated with its sample rules as a DRAFT version. Existing facts are skipped \u2014 apply is additive and never overwrites existing schema. Run lexq_domain_templates_preview first to review what will be created. Only ACTIVE templates can be applied.",
+      description: "Apply a domain template to the current tenant. Creates the template's fact definitions and a new policy group pre-populated with its sample rules as a DRAFT version. Apply never overwrites existing schema: a key that already exists with the same definition is kept as it is. Run lexq_domain_templates_preview first. If its factConflicts is not empty, apply fails with P-061 and creates nothing until those facts are deleted or changed to match the template. A template whose isAvailable is false cannot be applied.",
       inputSchema: z14.object({
         template: z14.string().describe("Domain template key to apply (e.g. ECOMMERCE)."),
         customName: z14.string().optional().describe(
@@ -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.4",
+  "version": "1.1.6",
   "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\"",