@lexq/cli 0.4.0 → 1.0.0

package/README.md

@@ -277,7 +277,7 @@ Checks that guard a stated fact against the thing that owns it. All of them run
 
 ```bash
 pnpm enums:check                # Generated enums match the engine contract
-pnpm constants:check            # Numbers written in prose match the contract
+pnpm prose:check                # Numbers and code tables in prose match the contract
 pnpm ab-key:check               # Tool descriptions still name the A/B traffic key
 pnpm surface:check              # Nothing internal reached a public file
 pnpm registry:check             # server.json agrees with package.json

package/dist/index.js

@@ -72,6 +72,7 @@ var survivesDoubleRoundTrip = (literal) => isSafeNumber(literal);
 var parseNumber = (value) => survivesDoubleRoundTrip(value) ? parseFloat(value) : new LosslessNumber(value);
 var parseJson = (text) => losslessParse(text, void 0, parseNumber);
 var stringifyJson = (value, space) => losslessStringify(value, void 0, space);
+var isLosslessNumber = (value) => value instanceof LosslessNumber;
 
 // src/lib/api-client.ts
 var ApiError = class extends Error {
@@ -1338,7 +1339,7 @@ ${data.length} unregistered`);
       process.exit(1);
     }
   });
-  facts.command("create").description("Create a new fact definition").option("--key <key>", "Fact key (letters, numbers, underscores)").option("--name <n>", "Display name").option("--type <type>", "Value type: STRING, NUMBER, BOOLEAN, LIST_STRING, LIST_NUMBER").option("--description <desc>", "Description").option("--required", "Mark as required", false).option("--pii", "Mark as PII \u2014 value is masked on every read surface", false).option("--json <body>", "Full request body as JSON (overrides other options)").addHelpText(
+  facts.command("create").description("Create a new fact definition").option("--key <key>", "Fact key (letters, numbers, underscores)").option("--name <n>", "Display name").option("--type <type>", "Value type: STRING, NUMBER, BOOLEAN, LIST_STRING, LIST_NUMBER").option("--description <desc>", "Description").option("--required", "Mark as required", false).option("--pii", "Mark as PII \u2014 value is masked on every read surface", false).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("--json <body>", "Full request body as JSON (overrides other options)").addHelpText(
     "after",
     dedent6`
 
@@ -1354,9 +1355,21 @@ ${data.length} unregistered`);
               "isRequired": false
             }'
 
+          $ lexq facts create --key riskScore --name "Risk Score" --type NUMBER --min 0 --max 100
+          $ lexq facts create --key tier --name "Tier" --type STRING \
+              --allowed-values "GOLD, SILVER, BRONZE"
+
         Value Types: STRING, NUMBER, BOOLEAN, LIST_STRING, LIST_NUMBER
         Key Format:  starts with a letter, then letters, numbers, and underscores.
                      Casing is yours to choose (e.g., paymentAmount, payment_amount)
+
+        Value Domain: --allowed-values, --min, and --max say which values the fact accepts.
+                      A rule can then only compare against those values, and the console turns
+                      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.
       `
   ).action(async (opts) => {
     try {
@@ -1375,14 +1388,25 @@ ${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("--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").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(
     "after",
     dedent6`
 
-        System facts cannot be modified. Only display name, description, and required flag can be changed.
+        System facts accept name, description, and the PII flag only.
 
-        Example:
+        Examples:
           $ lexq facts update --id <factId> --name "Updated Name" --required
+          $ lexq facts update --id <factId> --min 0 --max 100
+          $ 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.
+
+        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.
+
+        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.
       `
   ).action(async (opts) => {
     try {
@@ -1496,16 +1520,66 @@ function buildCreateBody2(opts) {
     isPii: opts.pii === true
   };
   if (opts.description) body.description = opts.description;
+  const domain = buildValueDomain(opts, opts.type);
+  if (domain) body.valueDomain = domain;
   return body;
 }
 function buildUpdateBody2(opts) {
   const body = {};
   if (opts.name) body.name = opts.name;
   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 (opts.clearValueDomain === true) {
+    if (hasDomainFlag(opts)) {
+      throw new Error(
+        "--clear-value-domain cannot be combined with --allowed-values, --min, or --max."
+      );
+    }
+    body.valueDomain = {};
+    return body;
+  }
+  const domain = buildValueDomain(opts, opts.type);
+  if (domain) body.valueDomain = domain;
   return body;
 }
+function hasDomainFlag(opts) {
+  return opts.allowedValues !== void 0 || opts.min !== void 0 || opts.max !== void 0;
+}
+function parseNumericLiteral(text, flag) {
+  let parsed;
+  try {
+    parsed = parseJson(text);
+  } catch {
+    throw new Error(`${flag} must be a number, got: ${text}`);
+  }
+  if (typeof parsed !== "number" && !isLosslessNumber(parsed)) {
+    throw new Error(`${flag} must be a number, got: ${text}`);
+  }
+  return parsed;
+}
+function asDomainValue(text, numeric) {
+  if (numeric === true) return parseNumericLiteral(text, "--allowed-values");
+  if (numeric === false) return text;
+  try {
+    const parsed = parseJson(text);
+    return typeof parsed === "number" || isLosslessNumber(parsed) ? parsed : text;
+  } catch {
+    return text;
+  }
+}
+function buildValueDomain(opts, type) {
+  if (!hasDomainFlag(opts)) return void 0;
+  const numeric = type === void 0 ? void 0 : type === "NUMBER" || type === "LIST_NUMBER";
+  const domain = {};
+  if (opts.allowedValues !== void 0) {
+    domain.allowedValues = opts.allowedValues.split(",").map((part) => part.trim()).filter((part) => part.length > 0).map((part) => asDomainValue(part, numeric));
+  }
+  if (opts.min !== void 0) domain.min = parseNumericLiteral(opts.min, "--min");
+  if (opts.max !== void 0) domain.max = parseNumericLiteral(opts.max, "--max");
+  return domain;
+}
 
 // src/commands/deploy.ts
 import "commander";
@@ -3909,6 +3983,15 @@ function registerFactTools(server, callApi) {
         isRequired: z5.boolean().default(false).describe("Whether this fact is required for rule evaluation"),
         isPii: z5.boolean().default(false).describe(
           "Mark as PII \u2014 masked on every read surface, revealable only in the console (audited)"
+        ),
+        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."
+          ),
+          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."
         )
       })
     },
@@ -3928,7 +4011,16 @@ function registerFactTools(server, callApi) {
           "Value type. Omit to leave it unchanged. Changing it fails with FD-007 while any rule references the fact."
         ),
         isRequired: z5.boolean().optional().describe("Required flag"),
-        isPii: z5.boolean().optional().describe("PII flag \u2014 enables/disables masking (changeable even on system facts)")
+        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."
+          ),
+          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."
+        )
       })
     },
     async ({ factId, ...body }) => callApi("PUT", `schema/facts/${factId}`, { body })

package/dist/mcp/register.js

@@ -586,6 +586,15 @@ function registerFactTools(server, callApi) {
         isRequired: z5.boolean().default(false).describe("Whether this fact is required for rule evaluation"),
         isPii: z5.boolean().default(false).describe(
           "Mark as PII \u2014 masked on every read surface, revealable only in the console (audited)"
+        ),
+        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."
+          ),
+          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."
         )
       })
     },
@@ -605,7 +614,16 @@ function registerFactTools(server, callApi) {
           "Value type. Omit to leave it unchanged. Changing it fails with FD-007 while any rule references the fact."
         ),
         isRequired: z5.boolean().optional().describe("Required flag"),
-        isPii: z5.boolean().optional().describe("PII flag \u2014 enables/disables masking (changeable even on system facts)")
+        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."
+          ),
+          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."
+        )
       })
     },
     async ({ factId, ...body }) => callApi("PUT", `schema/facts/${factId}`, { body })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lexq/cli",
-  "version": "0.4.0",
+  "version": "1.0.0",
   "mcpName": "io.lexq/lexq",
   "description": "LexQ CLI — manage policies, simulate rules, and deploy from the terminal. Built for humans and AI agents.",
   "type": "module",
@@ -30,7 +30,7 @@
     "typecheck": "tsc --noEmit",
     "enums": "node scripts/gen-enums.mjs",
     "enums:check": "node scripts/gen-enums.mjs --check",
-    "constants:check": "node scripts/check-constants.mjs",
+    "prose:check": "node scripts/check-prose-mirrors.mjs",
     "surface:check": "node scripts/check-public-surface.mjs",
     "ab-key:check": "node scripts/check-ab-key.mjs",
     "registry:check": "node scripts/check-registry-manifest.mjs",
@@ -41,6 +41,7 @@
     "test:decimals": "pnpm build && node tests/exact-decimals.mjs",
     "test:fact-key": "node tests/fact-key.mjs",
     "test:export-format": "node tests/export-format.mjs",
+    "test:value-domain": "pnpm build && node tests/value-domain.mjs",
     "prepublishOnly": "pnpm build",
     "knip": "knip",
     "format": "prettier --write \"src/**/*.ts\"",

package/skills/lexq-recipes/SKILL.md

@@ -20,7 +20,11 @@ lexq versions create --group-id <gid> --json '{"commitMessage": "Initial tiered
 
 # 3. Register facts (skip if already exist)
 lexq facts create --key paymentAmount --name "Payment Amount" --type NUMBER --required
-lexq facts create --key customerTier --name "Customer Tier" --type STRING
+lexq facts create --key customerTier --name "Customer Tier" --type STRING \
+  --allowed-values "VIP, GOLD, SILVER"
+# A value domain says which values the fact accepts. It refuses a rule literal that could
+# never match (a typo like "PLATNUM"), and the Console offers a dropdown instead of a text box.
+# Leave it off when the set is open — a country code, an account id, a free-text label.
 
 # 4. Add rules — creation order becomes priority order (first created = priority 1 = highest)
 lexq rules create --group-id <gid> --version-id <vid> --json '{

package/skills/lexq-shared/SKILL.md

@@ -47,6 +47,7 @@ This is the typical lifecycle. **Always follow this order:**
 1. lexq groups create          → Create a policy group
 2. lexq versions create        → Create a DRAFT version inside it
 3. lexq facts create           → Register input variables (if not already defined)
+                               → --allowed-values / --min / --max constrain what callers may send
 4. lexq rules create           → Add rules with conditions + actions
 5. lexq analytics dry-run      → Test with sample facts (validate before publish)
 6. lexq deploy publish         → DRAFT → ACTIVE (locks the version)

package/skills/lexq-simulation/SKILL.md

@@ -186,12 +186,18 @@ rule you expect never appears in `decisionTraces`, check the version's `effectiv
 - **empty** — the condition was evaluated and did not match
 - **`Evaluation error: <code>`** — the condition could not be evaluated at all
 
-| Code                    | Meaning                                                            |
-|-------------------------|--------------------------------------------------------------------|
-| `FACT_NOT_PROVIDED`     | The rule references a fact absent from the request                 |
-| `FACT_TYPE_MISMATCH`    | The fact's runtime type does not match the condition               |
-| `UNSUPPORTED_FACT_TYPE` | Operator not valid for the fact's type (e.g. `CONTAINS` on a list) |
-| `MALFORMED_RULE`        | The stored rule is structurally invalid                            |
+Each code says **who fixes it**.
+
+| Code                           | Who fixes it | Meaning                                                    |
+|--------------------------------|--------------|------------------------------------------------------------|
+| `FACT_NOT_PROVIDED`            | the caller   | The rule reads a fact the request did not include          |
+| `FACT_TYPE_MISMATCH`           | the caller   | The value sent has the wrong type for the condition        |
+| `CONDITION_VALUE_TYPE_INVALID` | the author   | The literal stored in the rule is wrong for its operator   |
+| `MALFORMED_RULE`               | nobody       | The stored rule is structurally invalid. Report it         |
+
+`CONDITION_VALUE_TYPE_INVALID` is worth escalating. The right-hand side of a condition belongs
+to the rule, not to your request, so changing the payload will not help — the rule fails the
+same way for every caller. It also got past the check that is supposed to reject it on save.
 
 A rule from another group referencing facts you did not send yields `FACT_NOT_PROVIDED` — this
 is normal, not an error.