@lexq/cli 0.1.50 → 0.1.51

package/AGENTS.md

@@ -93,7 +93,7 @@ lexq facts create --key age --name "User Age" --type NUMBER
 lexq rules create --group-id $GID --version-id $VID --json '{
   "name": "Adult Check",
   "condition": {"type":"SINGLE","field":"age","operator":"GREATER_THAN_OR_EQUAL","value":18,"valueType":"NUMBER"},
-  "actions": [{"type":"SET_FACT","parameters":{"targetVar":"is_adult","value":true}}]
+  "actions": [{"type":"SET_FACT","parameters":{"targetVar":"isAdult","value":true}}]
 }'
 
 # 5. Test
@@ -151,7 +151,8 @@ The MCP toolset mirrors the CLI command inventory one-to-one.
 - Every response is an envelope: the success branch carries `data`; the failure branch carries `errorCode` +
   `message`. Surface both — never a bare "request failed".
 - Pagination is asymmetric: requests send `page`/`size`, responses return `pageNo`/`pageSize`. Pages are 0-indexed.
-- Fact keys are `snake_case` and case-sensitive.
+- Fact keys start with a letter, then letters, numbers, and underscores. Casing is yours to choose
+  and keys are case-sensitive. These docs use `camelCase`.
 - Actions never call external systems. The engine mutates facts and records the decision — read the response and
   act on it yourself. Deployment lifecycle webhooks (`lexq webhook-subscriptions`) are the one push channel.
 
@@ -175,6 +176,7 @@ The MCP toolset mirrors the CLI command inventory one-to-one.
   the single api-client layer.
 - The hosted MCP server consumes this package from npm. Publish (`v*` tag) **before** redeploying it — CI cannot
   catch that ordering.
-- Gates before commit: `pnpm typecheck` (zero errors), `pnpm lint` (zero warnings), `bash tests/e2e.sh`.
+- Gates before commit: `pnpm typecheck` (zero errors), `pnpm lint` (zero warnings), `pnpm test:fact-key`,
+  `pnpm test:decimals`.
 - Multi-line CLI help and MCP tool descriptions use `dedent` — template-literal indentation leaks into LLM context.
 - Types mirror engine DTOs exactly; never invent response shapes.

package/CONTEXT.md

@@ -142,7 +142,7 @@ implemented).
 | **Policy Version**       | An immutable snapshot of rules. Only DRAFT versions can be modified.                                                                                           |
 | **Policy Rule**          | A condition → actions pair. Evaluated in priority order within a version.                                                                                      |
 | **Fact**                 | An input variable passed during execution. Declared via Fact Definitions with key, type, and name.                                                             |
-| **Fact Definition**      | Schema declaration for a fact — its key (snake_case), value type, display name, and description.                                                               |
+| **Fact Definition**      | Schema declaration for a fact — its key, value type, display name, and description.                                                                            |
 | **Dry Run**              | Single-input test execution. Returns which rules matched, what actions would fire, and decision traces.                                                        |
 | **Simulation**           | Batch test replaying historical executions against a version. Compares with a baseline.                                                                        |
 | **Activation Group**     | A logical grouping of Policy Groups for cross-group conflict resolution.                                                                                       |

package/README.md

@@ -60,7 +60,7 @@ lexq domain-templates apply --template ECOMMERCE
 
 # 4. Test a rule against your data before shipping
 lexq analytics dry-run --version-id <VERSION_ID> --debug \
-  --json '{"facts":{"loyalty_tier":"PLATINUM","purchase_subtotal_usd":150}}'
+  --json '{"facts":{"loyaltyTier":"PLATINUM","purchaseSubtotalUsd":150}}'
 
 # 5. Deploy
 lexq deploy publish --group-id <GROUP_ID> --version-id <VERSION_ID> --memo "v1"
@@ -235,8 +235,8 @@ pnpm start -- groups list
 ```bash
 pnpm typecheck                  # Type check
 pnpm lint                       # ESLint
-bash tests/e2e.sh               # CLI E2E tests (requires API key)
-bash tests/test-engine-api.sh   # Engine API integration tests
+pnpm test:fact-key              # Fact key grammar
+pnpm test:decimals              # Metric precision display
 ```
 
 ## License

package/dist/index.js

@@ -954,13 +954,13 @@ ${data.length} total`);
               "name": "VIP 20% Discount",
               "condition": {
                 "type": "SINGLE",
-                "field": "customer_tier",
+                "field": "customerTier",
                 "operator": "EQUALS",
                 "value": "VIP",
                 "valueType": "STRING"
               },
               "actions": [
-                { "type": "MUTATE_FACT", "parameters": { "targetVar": "payment_amount", "operator": "SUB", "method": "PERCENTAGE", "operand": 20 } }
+                { "type": "MUTATE_FACT", "parameters": { "targetVar": "paymentAmount", "operator": "SUB", "method": "PERCENTAGE", "operand": 20 } }
               ]
             }'
 
@@ -980,7 +980,7 @@ ${data.length} total`);
           HAS_NONE   fact has none of the given values
 
           Example:
-            { "type": "SINGLE", "field": "user_tags", "operator": "HAS_ANY",
+            { "type": "SINGLE", "field": "userTags", "operator": "HAS_ANY",
               "value": ["VIP", "GOLD"], "valueType": "LIST_STRING" }
 
           CONTAINS is substring match on STRING facts, not list membership.
@@ -1036,7 +1036,7 @@ ${data.length} total`);
           $ lexq rules update --group-id <gid> --version-id <vid> --id <rid> --json '{
               "name": "VIP 25% Discount",
               "actions": [
-                { "type": "MUTATE_FACT", "parameters": { "targetVar": "payment_amount", "operator": "SUB", "method": "PERCENTAGE", "operand": 25 } }
+                { "type": "MUTATE_FACT", "parameters": { "targetVar": "paymentAmount", "operator": "SUB", "method": "PERCENTAGE", "operand": 25 } }
               ]
             }'
       `
@@ -1180,7 +1180,7 @@ function registerFactCommands(program) {
           delete           Remove a fact definition
           action-metadata  Show action runtime fact metadata
 
-        System facts (user_id, user_tags) are auto-created.
+        System facts (userId, userTags) are auto-created.
       `
   );
   facts.command("list").description("List fact definitions").option("--keyword <keyword>", "Filter by keyword").option("--page <number>", "Page number", "0").option("--size <number>", "Page size", "20").action(async (opts) => {
@@ -1266,16 +1266,16 @@ ${data.length} unregistered`);
       process.exit(1);
     }
   });
-  facts.command("create").description("Create a new fact definition").option("--key <key>", "Fact key (lowercase, 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("--json <body>", "Full request body as JSON (overrides other options)").addHelpText(
     "after",
     dedent6`
 
         Examples:
-          $ lexq facts create --key customer_tier --name "Customer Tier" --type STRING
-          $ lexq facts create --key order_total --name "Order Total" --type NUMBER --required
+          $ lexq facts create --key customerTier --name "Customer Tier" --type STRING
+          $ lexq facts create --key orderTotal --name "Order Total" --type NUMBER --required
 
           $ lexq facts create --json '{
-              "key": "user_region",
+              "key": "userRegion",
               "name": "User Region",
               "type": "STRING",
               "description": "ISO country code",
@@ -1283,7 +1283,8 @@ ${data.length} unregistered`);
             }'
 
         Value Types: STRING, NUMBER, BOOLEAN, LIST_STRING, LIST_NUMBER
-        Key Format:  lowercase letters, numbers, underscores only (e.g., payment_amount)
+        Key Format:  starts with a letter, then letters, numbers, and underscores.
+                     Casing is yours to choose (e.g., paymentAmount, payment_amount)
       `
   ).action(async (opts) => {
     try {
@@ -1868,7 +1869,7 @@ function registerAnalyticsCommands(program) {
 
         Examples:
           $ lexq analytics dry-run --version-id <vid> --debug \\
-              --json '{"facts": {"payment_amount": 150000, "customer_tier": "VIP"}}'
+              --json '{"facts": {"paymentAmount": 150000, "customerTier": "VIP"}}'
 
           $ lexq analytics dry-run --version-id <vid> --file test-input.json
 
@@ -1907,7 +1908,7 @@ function registerAnalyticsCommands(program) {
           $ lexq analytics dry-run-compare --json '{
               "versionIdA": "<version-a-id>",
               "versionIdB": "<version-b-id>",
-              "facts": {"payment_amount": 100000, "customer_tier": "VIP"}
+              "facts": {"paymentAmount": 100000, "customerTier": "VIP"}
             }'
 
         Shows side-by-side which rules matched and what actions fired for each version.
@@ -3585,7 +3586,7 @@ function registerRuleTools(server, callApi) {
         - HAS_ANY: fact has at least one of the given values
         - HAS_ALL: fact has all of the given values
         - HAS_NONE: fact has none of the given values
-        Example: { "type": "SINGLE", "field": "user_tags", "operator": "HAS_ANY", "value": ["VIP","GOLD"], "valueType": "LIST_STRING" }
+        Example: { "type": "SINGLE", "field": "userTags", "operator": "HAS_ANY", "value": ["VIP","GOLD"], "valueType": "LIST_STRING" }
 
         Do NOT use CONTAINS on a list fact — CONTAINS is substring match on STRING facts only.
         IN is the mirror of HAS_*: IN takes a scalar fact with a list value; HAS_* takes lists on both sides.
@@ -3603,7 +3604,7 @@ function registerRuleTools(server, callApi) {
           refVar is the base for percentage calculation and is OPTIONAL — omit it to use targetVar
           itself. It is only meaningful in PERCENTAGE × {ASSIGN, ADD, SUB}; specifying it in any
           other cell is an error. Use it when the base differs from the target, e.g.
-          "points += order_total × 5%" → { targetVar: "points", refVar: "order_total",
+          "points += orderTotal × 5%" → { targetVar: "points", refVar: "orderTotal",
           operator: "ADD", method: "PERCENTAGE", operand: 5 }.
           operator × method matrix:
             ASSIGN  targetVar = operand              | targetVar = refVar × operand/100
@@ -3617,7 +3618,7 @@ function registerRuleTools(server, callApi) {
           — this is the only action that does. MUTATE_FACT requires the target to already exist.
         - BLOCK: { reason: string } Records a rejection decision. It does NOT halt rule execution —
           subsequent actions and subsequent winning rules still run. Enforcement is the caller's
-          responsibility; the decision surfaces as the is_blocked fact.
+          responsibility; the decision surfaces as the isBlocked fact.
 
         RoundingOption (optional, MUTATE_FACT only): { scale: integer (0..${MAX_ROUNDING_SCALE}), mode?: "HALF_UP"|"HALF_DOWN"|"HALF_EVEN"|"FLOOR"|"CEILING"|"DOWN"|"UP" } mode defaults to HALF_UP. When omitted, calculator output is preserved at full precision (lossless).
       `,
@@ -3716,6 +3717,11 @@ function registerRuleTools(server, callApi) {
 
 // src/mcp/tools/facts.ts
 import { z as z4 } from "zod";
+
+// src/types/facts.ts
+var FACT_KEY_PATTERN = /^[a-zA-Z][a-zA-Z0-9_]*$/;
+
+// src/mcp/tools/facts.ts
 function registerFactTools(server, callApi) {
   server.registerTool(
     "lexq_facts_list",
@@ -3738,9 +3744,9 @@ function registerFactTools(server, callApi) {
     "lexq_facts_create",
     {
       title: "Create Fact Definition",
-      description: "Register a new input variable. Key must be lowercase with underscores (e.g. payment_amount). Types: STRING, NUMBER, BOOLEAN, LIST_STRING, LIST_NUMBER.",
+      description: "Register a new input variable. Key starts with a letter, then letters, numbers, and underscores (e.g. paymentAmount). Casing is not enforced. Types: STRING, NUMBER, BOOLEAN, LIST_STRING, LIST_NUMBER.",
       inputSchema: {
-        key: z4.string().regex(/^[a-z][a-z0-9_]*$/).describe("Variable key (snake_case)"),
+        key: z4.string().regex(FACT_KEY_PATTERN).describe("Variable key. Any casing; must start with a letter."),
         name: z4.string().describe("Display name"),
         type: z4.enum(["STRING", "NUMBER", "BOOLEAN", "LIST_STRING", "LIST_NUMBER"]).describe("Value type"),
         description: z4.string().optional().describe("Description"),
@@ -3981,16 +3987,16 @@ function registerAnalyticsTools(server, callApi) {
         
         Returns:
           inputFacts        — normalized input facts
-          mutatedFacts      — input facts changed by rule actions (e.g. MUTATE_FACT mutates payment_amount)
-          generatedVariables — system-generated values; every fact in mutatedFacts gets a paired {fact_name}__delta key (signed difference)
+          mutatedFacts      — input facts changed by rule actions (e.g. MUTATE_FACT mutates paymentAmount)
+          generatedVariables — system-generated values; every fact in mutatedFacts gets a paired {factName}__delta key (signed difference)
           executionTraces   — per-rule match status
           decisionTraces    — per-rule decision (SELECTED / NO_MATCH / BLOCKED / etc.)
         
-        Example input: { "facts": { "payment_amount": 100000, "customer_tier": "VIP" } }
+        Example input: { "facts": { "paymentAmount": 100000, "customerTier": "VIP" } }
         Always dry-run before publishing to validate rule behavior.`,
       inputSchema: {
         versionId: z6.string().uuid().describe("Policy version ID to test against"),
-        facts: z6.string().describe('JSON string of facts object, e.g. {"payment_amount":100000}'),
+        facts: z6.string().describe('JSON string of facts object, e.g. {"paymentAmount":100000}'),
         includeDebugInfo: z6.boolean().default(true).describe("Include execution and decision traces")
       }
     },
@@ -4147,11 +4153,11 @@ function registerAnalyticsTools(server, callApi) {
           dataset: { "type": "UPLOADED", "source": "S3_BUCKET", "path": "<returned path>" }
 
         CSV example:
-        user_id,payment_amount
+        userId,paymentAmount
         user_001,150000
         user_002,50000
 
-        JSON example: [{"user_id":"user_001","payment_amount":150000}, {"user_id":"user_002","payment_amount":50000}]
+        JSON example: [{"userId":"user_001","paymentAmount":150000}, {"userId":"user_002","paymentAmount":50000}]
       `,
       inputSchema: {
         content: z6.string().describe("CSV or JSON content as string"),

package/dist/mcp/register.js

@@ -378,7 +378,7 @@ function registerRuleTools(server, callApi) {
         - HAS_ANY: fact has at least one of the given values
         - HAS_ALL: fact has all of the given values
         - HAS_NONE: fact has none of the given values
-        Example: { "type": "SINGLE", "field": "user_tags", "operator": "HAS_ANY", "value": ["VIP","GOLD"], "valueType": "LIST_STRING" }
+        Example: { "type": "SINGLE", "field": "userTags", "operator": "HAS_ANY", "value": ["VIP","GOLD"], "valueType": "LIST_STRING" }
 
         Do NOT use CONTAINS on a list fact — CONTAINS is substring match on STRING facts only.
         IN is the mirror of HAS_*: IN takes a scalar fact with a list value; HAS_* takes lists on both sides.
@@ -396,7 +396,7 @@ function registerRuleTools(server, callApi) {
           refVar is the base for percentage calculation and is OPTIONAL — omit it to use targetVar
           itself. It is only meaningful in PERCENTAGE × {ASSIGN, ADD, SUB}; specifying it in any
           other cell is an error. Use it when the base differs from the target, e.g.
-          "points += order_total × 5%" → { targetVar: "points", refVar: "order_total",
+          "points += orderTotal × 5%" → { targetVar: "points", refVar: "orderTotal",
           operator: "ADD", method: "PERCENTAGE", operand: 5 }.
           operator × method matrix:
             ASSIGN  targetVar = operand              | targetVar = refVar × operand/100
@@ -410,7 +410,7 @@ function registerRuleTools(server, callApi) {
           — this is the only action that does. MUTATE_FACT requires the target to already exist.
         - BLOCK: { reason: string } Records a rejection decision. It does NOT halt rule execution —
           subsequent actions and subsequent winning rules still run. Enforcement is the caller's
-          responsibility; the decision surfaces as the is_blocked fact.
+          responsibility; the decision surfaces as the isBlocked fact.
 
         RoundingOption (optional, MUTATE_FACT only): { scale: integer (0..${MAX_ROUNDING_SCALE}), mode?: "HALF_UP"|"HALF_DOWN"|"HALF_EVEN"|"FLOOR"|"CEILING"|"DOWN"|"UP" } mode defaults to HALF_UP. When omitted, calculator output is preserved at full precision (lossless).
       `,
@@ -509,6 +509,11 @@ function registerRuleTools(server, callApi) {
 
 // src/mcp/tools/facts.ts
 import { z as z4 } from "zod";
+
+// src/types/facts.ts
+var FACT_KEY_PATTERN = /^[a-zA-Z][a-zA-Z0-9_]*$/;
+
+// src/mcp/tools/facts.ts
 function registerFactTools(server, callApi) {
   server.registerTool(
     "lexq_facts_list",
@@ -531,9 +536,9 @@ function registerFactTools(server, callApi) {
     "lexq_facts_create",
     {
       title: "Create Fact Definition",
-      description: "Register a new input variable. Key must be lowercase with underscores (e.g. payment_amount). Types: STRING, NUMBER, BOOLEAN, LIST_STRING, LIST_NUMBER.",
+      description: "Register a new input variable. Key starts with a letter, then letters, numbers, and underscores (e.g. paymentAmount). Casing is not enforced. Types: STRING, NUMBER, BOOLEAN, LIST_STRING, LIST_NUMBER.",
       inputSchema: {
-        key: z4.string().regex(/^[a-z][a-z0-9_]*$/).describe("Variable key (snake_case)"),
+        key: z4.string().regex(FACT_KEY_PATTERN).describe("Variable key. Any casing; must start with a letter."),
         name: z4.string().describe("Display name"),
         type: z4.enum(["STRING", "NUMBER", "BOOLEAN", "LIST_STRING", "LIST_NUMBER"]).describe("Value type"),
         description: z4.string().optional().describe("Description"),
@@ -774,16 +779,16 @@ function registerAnalyticsTools(server, callApi) {
         
         Returns:
           inputFacts        — normalized input facts
-          mutatedFacts      — input facts changed by rule actions (e.g. MUTATE_FACT mutates payment_amount)
-          generatedVariables — system-generated values; every fact in mutatedFacts gets a paired {fact_name}__delta key (signed difference)
+          mutatedFacts      — input facts changed by rule actions (e.g. MUTATE_FACT mutates paymentAmount)
+          generatedVariables — system-generated values; every fact in mutatedFacts gets a paired {factName}__delta key (signed difference)
           executionTraces   — per-rule match status
           decisionTraces    — per-rule decision (SELECTED / NO_MATCH / BLOCKED / etc.)
         
-        Example input: { "facts": { "payment_amount": 100000, "customer_tier": "VIP" } }
+        Example input: { "facts": { "paymentAmount": 100000, "customerTier": "VIP" } }
         Always dry-run before publishing to validate rule behavior.`,
       inputSchema: {
         versionId: z6.string().uuid().describe("Policy version ID to test against"),
-        facts: z6.string().describe('JSON string of facts object, e.g. {"payment_amount":100000}'),
+        facts: z6.string().describe('JSON string of facts object, e.g. {"paymentAmount":100000}'),
         includeDebugInfo: z6.boolean().default(true).describe("Include execution and decision traces")
       }
     },
@@ -940,11 +945,11 @@ function registerAnalyticsTools(server, callApi) {
           dataset: { "type": "UPLOADED", "source": "S3_BUCKET", "path": "<returned path>" }
 
         CSV example:
-        user_id,payment_amount
+        userId,paymentAmount
         user_001,150000
         user_002,50000
 
-        JSON example: [{"user_id":"user_001","payment_amount":150000}, {"user_id":"user_002","payment_amount":50000}]
+        JSON example: [{"userId":"user_001","paymentAmount":150000}, {"userId":"user_002","paymentAmount":50000}]
       `,
       inputSchema: {
         content: z6.string().describe("CSV or JSON content as string"),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lexq/cli",
-  "version": "0.1.50",
+  "version": "0.1.51",
   "description": "LexQ CLI — manage policies, simulate rules, and deploy from the terminal. Built for humans and AI agents.",
   "type": "module",
   "bin": {
@@ -32,6 +32,7 @@
     "constants:check": "node scripts/check-constants.mjs",
     "start": "node dist/index.js",
     "test:decimals": "pnpm build && node tests/exact-decimals.mjs",
+    "test:fact-key": "node tests/fact-key.mjs",
     "prepublishOnly": "pnpm build",
     "knip": "knip",
     "format": "prettier --write \"src/**/*.ts\"",

package/skills/lexq-execution/SKILL.md

@@ -191,7 +191,7 @@ Returns the decision, per-rule reason codes (`FINAL_WINNER`, `CONDITION_MISMATCH
 `GROUP_LIMIT_REACHED`, …), and the sealed version snapshot hash.
 
 A rule that lost conflict resolution has status `BLOCKED` — unrelated to the `BLOCK` action, which writes the
-`is_blocked` fact while its own rule stays `SELECTED`.
+`isBlocked` fact while its own rule stays `SELECTED`.
 
 ### PII Reveal Audit
 

package/skills/lexq-recipes/SKILL.md

@@ -19,15 +19,15 @@ lexq versions create --group-id <gid> --json '{"commitMessage": "Initial tiered
 # → Save the version ID
 
 # 3. Register facts (skip if already exist)
-lexq facts create --key payment_amount --name "Payment Amount" --type NUMBER --required
-lexq facts create --key customer_tier --name "Customer Tier" --type STRING
+lexq facts create --key paymentAmount --name "Payment Amount" --type NUMBER --required
+lexq facts create --key customerTier --name "Customer Tier" --type STRING
 
 # 4. Add rules — creation order becomes priority order (first created = priority 1 = highest)
 lexq rules create --group-id <gid> --version-id <vid> --json '{
   "name": "Premium Tier - 20%",
   "condition": {
     "type": "SINGLE",
-    "field": "payment_amount",
+    "field": "paymentAmount",
     "operator": "GREATER_THAN_OR_EQUAL",
     "value": 500000,
     "valueType": "NUMBER"
@@ -35,7 +35,7 @@ lexq rules create --group-id <gid> --version-id <vid> --json '{
   "actions": [{
     "type": "MUTATE_FACT",
     "parameters": {
-      "targetVar": "payment_amount",
+      "targetVar": "paymentAmount",
       "method": "PERCENTAGE",
       "operator": "SUB",
       "operand": 20,
@@ -50,14 +50,14 @@ lexq rules create --group-id <gid> --version-id <vid> --json '{
     "type": "GROUP",
     "operator": "AND",
     "children": [
-      { "type": "SINGLE", "field": "payment_amount", "operator": "GREATER_THAN_OR_EQUAL", "value": 100000, "valueType": "NUMBER" },
-      { "type": "SINGLE", "field": "payment_amount", "operator": "LESS_THAN", "value": 500000, "valueType": "NUMBER" }
+      { "type": "SINGLE", "field": "paymentAmount", "operator": "GREATER_THAN_OR_EQUAL", "value": 100000, "valueType": "NUMBER" },
+      { "type": "SINGLE", "field": "paymentAmount", "operator": "LESS_THAN", "value": 500000, "valueType": "NUMBER" }
     ]
   },
   "actions": [{
     "type": "MUTATE_FACT",
     "parameters": {
-      "targetVar": "payment_amount",
+      "targetVar": "paymentAmount",
       "method": "PERCENTAGE",
       "operator": "SUB",
       "operand": 10,
@@ -70,7 +70,7 @@ lexq rules create --group-id <gid> --version-id <vid> --json '{
   "name": "Base Tier - 5%",
   "condition": {
     "type": "SINGLE",
-    "field": "payment_amount",
+    "field": "paymentAmount",
     "operator": "GREATER_THAN_OR_EQUAL",
     "value": 30000,
     "valueType": "NUMBER"
@@ -78,7 +78,7 @@ lexq rules create --group-id <gid> --version-id <vid> --json '{
   "actions": [{
     "type": "MUTATE_FACT",
     "parameters": {
-      "targetVar": "payment_amount",
+      "targetVar": "paymentAmount",
       "method": "PERCENTAGE",
       "operator": "SUB",
       "operand": 5,
@@ -88,11 +88,11 @@ lexq rules create --group-id <gid> --version-id <vid> --json '{
 }'
 
 # 5. Validate
-lexq analytics dry-run --version-id <vid> --debug --json '{"facts":{"payment_amount":600000}}'
-# Expected: mutatedFacts.payment_amount = 480000, generatedVariables.payment_amount__delta = -120000
+lexq analytics dry-run --version-id <vid> --debug --json '{"facts":{"paymentAmount":600000}}'
+# Expected: mutatedFacts.paymentAmount = 480000, generatedVariables.paymentAmount__delta = -120000
 
-lexq analytics dry-run --version-id <vid> --debug --json '{"facts":{"payment_amount":200000}}'
-# Expected: mutatedFacts.payment_amount = 180000, generatedVariables.payment_amount__delta = -20000
+lexq analytics dry-run --version-id <vid> --debug --json '{"facts":{"paymentAmount":200000}}'
+# Expected: mutatedFacts.paymentAmount = 180000, generatedVariables.paymentAmount__delta = -20000
 
 # 6. Deploy
 lexq deploy publish --group-id <gid> --version-id <vid> --memo "Tiered discount v1"
@@ -113,9 +113,9 @@ lexq groups create --json '{
 
 lexq versions create --group-id <gid> --json '{"commitMessage": "Fraud rules v1"}'
 
-lexq facts create --key transaction_amount --name "Transaction Amount" --type NUMBER --required
-lexq facts create --key transaction_count_24h --name "Transactions in 24h" --type NUMBER
-lexq facts create --key country_code --name "Country Code" --type STRING
+lexq facts create --key transactionAmount --name "Transaction Amount" --type NUMBER --required
+lexq facts create --key transactionCount24h --name "Transactions in 24h" --type NUMBER
+lexq facts create --key countryCode --name "Country Code" --type STRING
 
 # High-value + high-frequency
 lexq rules create --group-id <gid> --version-id <vid> --json '{
@@ -124,8 +124,8 @@ lexq rules create --group-id <gid> --version-id <vid> --json '{
     "type": "GROUP",
     "operator": "AND",
     "children": [
-      { "type": "SINGLE", "field": "transaction_amount", "operator": "GREATER_THAN", "value": 5000000, "valueType": "NUMBER" },
-      { "type": "SINGLE", "field": "transaction_count_24h", "operator": "GREATER_THAN", "value": 10, "valueType": "NUMBER" }
+      { "type": "SINGLE", "field": "transactionAmount", "operator": "GREATER_THAN", "value": 5000000, "valueType": "NUMBER" },
+      { "type": "SINGLE", "field": "transactionCount24h", "operator": "GREATER_THAN", "value": 10, "valueType": "NUMBER" }
     ]
   },
   "actions": [
@@ -138,7 +138,7 @@ lexq rules create --group-id <gid> --version-id <vid> --json '{
   "name": "Sanctioned Country Block",
   "condition": {
     "type": "SINGLE",
-    "field": "country_code",
+    "field": "countryCode",
     "operator": "IN",
     "value": ["XX", "YY", "ZZ"],
     "valueType": "LIST_STRING"
@@ -150,7 +150,7 @@ lexq rules create --group-id <gid> --version-id <vid> --json '{
 
 # Validate
 lexq analytics dry-run --version-id <vid> --debug --json '{
-  "facts": { "transaction_amount": 10000000, "transaction_count_24h": 15, "country_code": "KR" }
+  "facts": { "transactionAmount": 10000000, "transactionCount24h": 15, "countryCode": "KR" }
 }'
 ```
 
@@ -172,7 +172,7 @@ lexq rules update --group-id <gid> --version-id <v2id> --id <ruleId> --json '{
   "actions": [{
     "type": "MUTATE_FACT",
     "parameters": {
-      "targetVar": "payment_amount",
+      "targetVar": "paymentAmount",
       "method": "PERCENTAGE",
       "operator": "SUB",
       "operand": 15,
@@ -183,7 +183,7 @@ lexq rules update --group-id <gid> --version-id <v2id> --id <ruleId> --json '{
 
 # 3. Validate with dry-run
 lexq analytics dry-run --version-id <v2id> --debug --json '{
-  "facts": { "payment_amount": 100000, "customer_tier": "VIP" }
+  "facts": { "paymentAmount": 100000, "customerTier": "VIP" }
 }'
 
 # 4. Publish v2
@@ -210,7 +210,7 @@ lexq groups ab-test stop --group-id <gid> --force
 
 **Goal:** Award loyalty points based on purchase behavior.
 
-**Note:** `total_points` must be present in the request facts. The engine is stateless — it does
+**Note:** `totalPoints` must be present in the request facts. The engine is stateless — it does
 not read your database. Send the customer's current balance (or `0` for a new customer) and apply
 the returned value yourself. `MUTATE_FACT` throws if the target fact is absent.
 
@@ -222,16 +222,16 @@ lexq groups create --json '{
 
 lexq versions create --group-id <gid> --json '{"commitMessage": "Points program v1"}'
 
-lexq facts create --key purchase_amount --name "Purchase Amount" --type NUMBER --required
-lexq facts create --key is_first_purchase --name "First Purchase" --type BOOLEAN
-lexq facts create --key total_points --name "Total Points" --type NUMBER --required
+lexq facts create --key purchaseAmount --name "Purchase Amount" --type NUMBER --required
+lexq facts create --key isFirstPurchase --name "First Purchase" --type BOOLEAN
+lexq facts create --key totalPoints --name "Total Points" --type NUMBER --required
 
 # Bonus points for first purchase (fixed 200)
 lexq rules create --group-id <gid> --version-id <vid> --json '{
   "name": "First Purchase Bonus Points",
   "condition": {
     "type": "SINGLE",
-    "field": "is_first_purchase",
+    "field": "isFirstPurchase",
     "operator": "EQUALS",
     "value": true,
     "valueType": "BOOLEAN"
@@ -240,7 +240,7 @@ lexq rules create --group-id <gid> --version-id <vid> --json '{
     {
       "type": "MUTATE_FACT",
       "parameters": {
-        "targetVar": "total_points",
+        "targetVar": "totalPoints",
         "operator": "ADD",
         "method": "AMOUNT",
         "operand": 200
@@ -249,12 +249,12 @@ lexq rules create --group-id <gid> --version-id <vid> --json '{
   ]
 }'
 
-# Standard points: 0.1% of purchase_amount = 1 point per 1000 KRW
+# Standard points: 0.1% of purchaseAmount = 1 point per 1000 KRW
 lexq rules create --group-id <gid> --version-id <vid> --json '{
   "name": "Standard Purchase Points",
   "condition": {
     "type": "SINGLE",
-    "field": "purchase_amount",
+    "field": "purchaseAmount",
     "operator": "GREATER_THAN_OR_EQUAL",
     "value": 1000,
     "valueType": "NUMBER"
@@ -263,8 +263,8 @@ lexq rules create --group-id <gid> --version-id <vid> --json '{
     {
       "type": "MUTATE_FACT",
       "parameters": {
-        "targetVar": "total_points",
-        "refVar": "purchase_amount",
+        "targetVar": "totalPoints",
+        "refVar": "purchaseAmount",
         "operator": "ADD",
         "method": "PERCENTAGE",
         "operand": 0.1,
@@ -276,14 +276,14 @@ lexq rules create --group-id <gid> --version-id <vid> --json '{
 
 # Verify — new customer, 50,000 KRW purchase → 200 bonus + 50 standard = 250
 lexq analytics dry-run --version-id <vid> --debug --json '{
-  "facts": { "purchase_amount": 50000, "is_first_purchase": true, "total_points": 0 }
+  "facts": { "purchaseAmount": 50000, "isFirstPurchase": true, "totalPoints": 0 }
 }'
 ```
 
-`total_points` and `refVar: purchase_amount` are two different facts — this is exactly what
-`refVar` exists for. Omitting it would compute `total_points += total_points × 0.1%`.
+`totalPoints` and `refVar: purchaseAmount` are two different facts — this is exactly what
+`refVar` exists for. Omitting it would compute `totalPoints += totalPoints × 0.1%`.
 
-Read `total_points` and `total_points__delta` from `generatedVariables` in the response.
+Read `totalPoints` and `totalPoints__delta` from `generatedVariables` in the response.
 
 ---
 
@@ -298,12 +298,12 @@ lexq rules create --group-id <gid> --version-id <vid> --json '{
   "mutexMode": "EXCLUSIVE",
   "mutexStrategy": "HIGHEST_PRIORITY",
   "condition": {
-    "type": "SINGLE", "field": "customer_tier", "operator": "EQUALS", "value": "VIP", "valueType": "STRING"
+    "type": "SINGLE", "field": "customerTier", "operator": "EQUALS", "value": "VIP", "valueType": "STRING"
   },
   "actions": [{
     "type": "MUTATE_FACT",
     "parameters": {
-      "targetVar": "payment_amount",
+      "targetVar": "paymentAmount",
       "method": "PERCENTAGE",
       "operator": "SUB",
       "operand": 20,
@@ -318,12 +318,12 @@ lexq rules create --group-id <gid> --version-id <vid> --json '{
   "mutexMode": "EXCLUSIVE",
   "mutexStrategy": "HIGHEST_PRIORITY",
   "condition": {
-    "type": "SINGLE", "field": "payment_amount", "operator": "GREATER_THAN_OR_EQUAL", "value": 50000, "valueType": "NUMBER"
+    "type": "SINGLE", "field": "paymentAmount", "operator": "GREATER_THAN_OR_EQUAL", "value": 50000, "valueType": "NUMBER"
   },
   "actions": [{
     "type": "MUTATE_FACT",
     "parameters": {
-      "targetVar": "payment_amount",
+      "targetVar": "paymentAmount",
       "method": "PERCENTAGE",
       "operator": "SUB",
       "operand": 15,
@@ -435,20 +435,20 @@ boolean or string flags are simpler and easier to query.
 lexq groups create --json '{"name": "segmentation", "activationMode": "NONE"}'
 lexq versions create --group-id <gid> --json '{"commitMessage": "Segments v1"}'
 
-lexq facts create --key lifetime_value --name "Lifetime Value" --type NUMBER --required
-lexq facts create --key signup_days --name "Days Since Signup" --type NUMBER --required
-lexq facts create --key support_tier --name "Support Tier" --type STRING
-lexq facts create --key beta_enabled --name "Beta Access" --type BOOLEAN
+lexq facts create --key lifetimeValue --name "Lifetime Value" --type NUMBER --required
+lexq facts create --key signupDays --name "Days Since Signup" --type NUMBER --required
+lexq facts create --key supportTier --name "Support Tier" --type STRING
+lexq facts create --key betaEnabled --name "Beta Access" --type BOOLEAN
 
 # High-value customer → priority support
 lexq rules create --group-id <gid> --version-id <vid> --json '{
   "name": "High Value Segment",
   "condition": {
-    "type": "SINGLE", "field": "lifetime_value",
+    "type": "SINGLE", "field": "lifetimeValue",
     "operator": "GREATER_THAN_OR_EQUAL", "value": 1000000, "valueType": "NUMBER"
   },
   "actions": [
-    { "type": "SET_FACT", "parameters": { "targetVar": "support_tier", "value": "PRIORITY" } }
+    { "type": "SET_FACT", "parameters": { "targetVar": "supportTier", "value": "PRIORITY" } }
   ]
 }'
 
@@ -456,16 +456,16 @@ lexq rules create --group-id <gid> --version-id <vid> --json '{
 lexq rules create --group-id <gid> --version-id <vid> --json '{
   "name": "Veteran Beta Access",
   "condition": {
-    "type": "SINGLE", "field": "signup_days",
+    "type": "SINGLE", "field": "signupDays",
     "operator": "GREATER_THAN", "value": 365, "valueType": "NUMBER"
   },
   "actions": [
-    { "type": "SET_FACT", "parameters": { "targetVar": "beta_enabled", "value": true } }
+    { "type": "SET_FACT", "parameters": { "targetVar": "betaEnabled", "value": true } }
   ]
 }'
 
 lexq analytics dry-run --version-id <vid> --debug --json '{
-  "facts": { "lifetime_value": 1500000, "signup_days": 400 }
+  "facts": { "lifetimeValue": 1500000, "signupDays": 400 }
 }'
 ```
 

package/skills/lexq-rules/SKILL.md

@@ -39,7 +39,7 @@ Conditions use a tree structure with two node types: `SINGLE` and `GROUP`.
 ```json
 {
   "type": "SINGLE",
-  "field": "payment_amount",
+  "field": "paymentAmount",
   "operator": "GREATER_THAN_OR_EQUAL",
   "value": 100000,
   "valueType": "NUMBER"
@@ -55,14 +55,14 @@ Conditions use a tree structure with two node types: `SINGLE` and `GROUP`.
   "children": [
     {
       "type": "SINGLE",
-      "field": "customer_tier",
+      "field": "customerTier",
       "operator": "EQUALS",
       "value": "VIP",
       "valueType": "STRING"
     },
     {
       "type": "SINGLE",
-      "field": "payment_amount",
+      "field": "paymentAmount",
       "operator": "GREATER_THAN",
       "value": 50000,
       "valueType": "NUMBER"
@@ -109,7 +109,7 @@ by the server — check `lexq facts list` before choosing.
 
 // list fact, list value
 {
-  "field": "user_tags",
+  "field": "userTags",
   "operator": "HAS_ANY",
   "value": [
     "VIP",
@@ -133,7 +133,7 @@ Do **not** use `CONTAINS` on a list fact — that idiom works in some rule engin
 
 ### Nested Conditions Example
 
-`(customer_tier = "VIP" AND payment_amount >= 100000) OR region IN ["KR", "JP"]`:
+`(customerTier = "VIP" AND paymentAmount >= 100000) OR region IN ["KR", "JP"]`:
 
 ```json
 {
@@ -146,14 +146,14 @@ Do **not** use `CONTAINS` on a list fact — that idiom works in some rule engin
       "children": [
         {
           "type": "SINGLE",
-          "field": "customer_tier",
+          "field": "customerTier",
           "operator": "EQUALS",
           "value": "VIP",
           "valueType": "STRING"
         },
         {
           "type": "SINGLE",
-          "field": "payment_amount",
+          "field": "paymentAmount",
           "operator": "GREATER_THAN_OR_EQUAL",
           "value": 100000,
           "valueType": "NUMBER"
@@ -218,8 +218,8 @@ Use `refVar` when the base differs from the target:
 {
   "type": "MUTATE_FACT",
   "parameters": {
-    "targetVar": "loyalty_point",
-    "refVar": "order_total",
+    "targetVar": "loyaltyPoint",
+    "refVar": "orderTotal",
     "operator": "ADD",
     "method": "PERCENTAGE",
     "operand": 5
@@ -227,8 +227,8 @@ Use `refVar` when the base differs from the target:
 }
 ```
 
-`loyalty_point += order_total × 5%` — two different facts. Omitting `refVar` would compute
-`loyalty_point += loyalty_point × 5%` instead.
+`loyaltyPoint += orderTotal × 5%` — two different facts. Omitting `refVar` would compute
+`loyaltyPoint += loyaltyPoint × 5%` instead.
 
 **Ranges are not constrained.** Negative operands and percentages above 100 are valid — refunds
 (`-5`), surcharges (`150`), risk scores, and game points all need them.
@@ -240,20 +240,20 @@ present as a number and throws otherwise. "Make something that wasn't there" is
 
 ### `BLOCK` does not halt execution
 
-`BLOCK` records a rejection decision by writing the `is_blocked` fact. Subsequent actions in the
+`BLOCK` records a rejection decision by writing the `isBlocked` fact. Subsequent actions in the
 same rule and subsequent winning rules still run. Enforcement is the caller's responsibility —
-read `is_blocked` from the response.
+read `isBlocked` from the response.
 
 ### Action Example: 10% Discount via MUTATE_FACT
 
-Reduces `payment_amount` by 10%. `__delta` is auto-generated in `generatedVariables` (e.g.,
-`payment_amount__delta: -10000` for a 100,000 input).
+Reduces `paymentAmount` by 10%. `__delta` is auto-generated in `generatedVariables` (e.g.,
+`paymentAmount__delta: -10000` for a 100,000 input).
 
 ```json
 {
   "type": "MUTATE_FACT",
   "parameters": {
-    "targetVar": "payment_amount",
+    "targetVar": "paymentAmount",
     "method": "PERCENTAGE",
     "operator": "SUB",
     "operand": 10,
@@ -301,15 +301,15 @@ lexq rules create --group-id <gid> --version-id <vid> --json '{
     "type": "GROUP",
     "operator": "AND",
     "children": [
-      { "type": "SINGLE", "field": "customer_tier", "operator": "EQUALS", "value": "VIP", "valueType": "STRING" },
-      { "type": "SINGLE", "field": "payment_amount", "operator": "GREATER_THAN_OR_EQUAL", "value": 100000, "valueType": "NUMBER" }
+      { "type": "SINGLE", "field": "customerTier", "operator": "EQUALS", "value": "VIP", "valueType": "STRING" },
+      { "type": "SINGLE", "field": "paymentAmount", "operator": "GREATER_THAN_OR_EQUAL", "value": 100000, "valueType": "NUMBER" }
     ]
   },
   "actions": [
     {
       "type": "MUTATE_FACT",
       "parameters": {
-        "targetVar": "payment_amount",
+        "targetVar": "paymentAmount",
         "method": "PERCENTAGE",
         "operator": "SUB",
         "operand": 10,
@@ -330,7 +330,7 @@ lexq rules update --group-id <gid> --version-id <vid> --id <ruleId> --json '{
     {
       "type": "MUTATE_FACT",
       "parameters": {
-        "targetVar": "payment_amount",
+        "targetVar": "paymentAmount",
         "method": "PERCENTAGE",
         "operator": "SUB",
         "operand": 15,
@@ -415,6 +415,6 @@ Before creating rules, always:
 
 1. **Check available facts:** `lexq facts list`
 2. **Confirm the version is DRAFT:** `lexq versions get --group-id <gid> --id <vid>` → status must be `DRAFT`
-3. **Use exact fact keys** from the fact definitions (snake_case, case-sensitive)
+3. **Use exact fact keys** from the fact definitions (case-sensitive)
 4. **Match value types** — a fact defined as `NUMBER` must receive numeric values, not strings
 5. **Match the operator to the fact type** — list-typed facts accept only `HAS_ANY` / `HAS_ALL` / `HAS_NONE`

package/skills/lexq-shared/SKILL.md

@@ -149,7 +149,8 @@ Prefixes you will encounter through the CLI:
 
 ## Important Conventions
 
-1. **Fact keys use `snake_case`.** Example: `payment_amount`, `customer_tier`. Always lowercase.
+1. **Fact keys start with a letter,** then letters, numbers, and underscores. Casing is yours to
+   choose and keys are case-sensitive. These docs use `camelCase`: `paymentAmount`, `customerTier`.
 2. **IDs are UUIDs.** Always copy the full ID from list/create output — do not guess.
 3. **Dates use ISO 8601.** Example: `2025-01-01T00:00:00Z`. Time zone is UTC.
 4. **JSON bodies via `--json`.** Most create/update commands accept `--json '<body>'` for the request body.

package/skills/lexq-simulation/SKILL.md

@@ -31,7 +31,7 @@ Response includes:
   "versionNo": 3,
   "requiredFacts": [
     {
-      "key": "payment_amount",
+      "key": "paymentAmount",
       "type": "NUMBER",
       "required": true,
       "usedBy": [
@@ -40,7 +40,7 @@ Response includes:
       ]
     },
     {
-      "key": "customer_tier",
+      "key": "customerTier",
       "type": "STRING",
       "required": true,
       "usedBy": [
@@ -50,8 +50,8 @@ Response includes:
   ],
   "exampleRequest": {
     "facts": {
-      "payment_amount": 0,
-      "customer_tier": ""
+      "paymentAmount": 0,
+      "customerTier": ""
     },
     "context": {}
   }
@@ -67,8 +67,8 @@ Test a single set of facts against a version:
 ```bash
 lexq analytics dry-run --version-id <vid> --json '{
   "facts": {
-    "payment_amount": 150000,
-    "customer_tier": "VIP"
+    "paymentAmount": 150000,
+    "customerTier": "VIP"
   }
 }'
 ```
@@ -84,7 +84,7 @@ lexq analytics dry-run --version-id <vid> --json '{
 
 ```bash
 lexq analytics dry-run --version-id <vid> --debug --json '{
-  "facts": { "payment_amount": 150000, "customer_tier": "VIP" }
+  "facts": { "paymentAmount": 150000, "customerTier": "VIP" }
 }'
 ```
 
@@ -98,22 +98,22 @@ external to mock.
   "result": "SUCCESS",
   "data": {
     "inputFacts": {
-      "payment_amount": 150000,
-      "customer_tier": "VIP"
+      "paymentAmount": 150000,
+      "customerTier": "VIP"
     },
     "mutatedFacts": {
-      "payment_amount": 135000,
-      "customer_tier": "VIP"
+      "paymentAmount": 135000,
+      "customerTier": "VIP"
     },
     "generatedVariables": {
-      "payment_amount__delta": -15000
+      "paymentAmount__delta": -15000
     },
     "executionTraces": [
       {
         "ruleId": "...",
         "ruleName": "VIP 10% Discount",
         "matched": true,
-        "matchExpression": "(customer_tier == 'VIP') && (payment_amount >= 100000)",
+        "matchExpression": "(customerTier == 'VIP') && (paymentAmount >= 100000)",
         "generatedActions": [
           {
             "type": "MUTATE_FACT",
@@ -139,8 +139,8 @@ external to mock.
 }
 ```
 
-- `mutatedFacts` — input facts changed by rule actions (e.g., `MUTATE_FACT` reduces `payment_amount`)
-- `generatedVariables` — for every fact in `mutatedFacts`, a paired `{fact_name}__delta` key is auto-generated with the
+- `mutatedFacts` — input facts changed by rule actions (e.g., `MUTATE_FACT` reduces `paymentAmount`)
+- `generatedVariables` — for every fact in `mutatedFacts`, a paired `{factName}__delta` key is auto-generated with the
   signed difference (negative = decrease, positive = increase)
 
 ### Reading Decision Traces
@@ -154,7 +154,7 @@ Each trace carries a `status` (what happened) and a `reasonCode` (why).
 | `BLOCKED`  | Matched but lost conflict resolution — see `reasonCode` for which round and why |
 | `ERROR`    | Action execution failed                                                         |
 
-`BLOCKED` is unrelated to the `BLOCK` action. A `BLOCK` action writes the `is_blocked` fact and its own rule stays
+`BLOCKED` is unrelated to the `BLOCK` action. A `BLOCK` action writes the `isBlocked` fact and its own rule stays
 `SELECTED`; `BLOCKED` means the rule was dropped by activation-group or mutex competition.
 
 ### Reading Reason Codes
@@ -197,7 +197,7 @@ Compare how two versions evaluate the same input:
 
 ```bash
 lexq analytics dry-run-compare --json '{
-  "facts": { "payment_amount": 150000, "customer_tier": "VIP" },
+  "facts": { "paymentAmount": 150000, "customerTier": "VIP" },
   "versionIdA": "<baselineVersionId>",
   "versionIdB": "<candidateVersionId>"
 }'
@@ -225,7 +225,7 @@ lexq analytics simulation start --json '{
     "maxRecords": 10000,
     "baselinePolicyVersionId": "<currentLiveVersionId>",
     "metricConfig": {
-      "targetVariable": "payment_amount__delta",
+      "targetVariable": "paymentAmount__delta",
       "aggregationType": "SUM"
     }
   }
@@ -316,7 +316,7 @@ lexq analytics simulation export --id <simulationId> --format csv --output resul
     "matchRate": 0.85
   },
   "metricSummary": {
-    "targetVariable": "payment_amount__delta",
+    "targetVariable": "paymentAmount__delta",
     "aggregationType": "SUM",
     "baselineValue": 5000000,
     "simulatedValue": 4500000,
@@ -353,7 +353,7 @@ lexq analytics requirements --group-id <gid> --version-id <vid>
 
 # 2. Dry-run with representative inputs
 lexq analytics dry-run --version-id <vid> --debug --json '{
-  "facts": { "payment_amount": 150000, "customer_tier": "VIP" }
+  "facts": { "paymentAmount": 150000, "customerTier": "VIP" }
 }'
 
 # 3. If dry-run looks good, publish
@@ -366,7 +366,7 @@ lexq analytics simulation start --json '{
   "options": {
     "baselinePolicyVersionId": "<currentLiveVersionId>",
     "includeRuleStats": true,
-    "metricConfig": { "targetVariable": "payment_amount__delta", "aggregationType": "SUM" }
+    "metricConfig": { "targetVariable": "paymentAmount__delta", "aggregationType": "SUM" }
   }
 }'