From d169adf3aff9df195bbbf360a51820bf5aa29409 Mon Sep 17 00:00:00 2001
From: Andreas Isler <andreas.isler@flowable.com>
Date: Fri, 10 Jul 2026 21:41:28 +0200
Subject: [PATCH] added REST model test, tests failing

---
 customer-work/docs/model-tests.md             | 370 +++++++++
 .../work/SecurityHttpBasicConfiguration.java  |   2 +-
 .../com/customer/work/service/VarUtil.java    | 741 ++++++++++++++++++
 .../com/customer/work/service/VarUtils.java   | 420 ----------
 .../src/main/resources/application.properties |   1 -
 .../work/model/FlowableExcelParser.java       |   8 +-
 .../work/model/FlowableModelTestUtils.java    |  10 +-
 .../customer/work/model/TestRestServer.java   |   1 +
 .../customer/work/model/test/ModelTest.java   |   4 +-
 .../service/VarUtilArrayTrackingTest.java     | 262 +++++++
 .../VarUtilExpressionFunctionsTest.java       | 154 ++++
 .../work/service/VarUtilMockScopeTest.java    |  81 ++
 .../customer/work/service/VarUtilTest.java    | 327 ++++++++
 .../src/test/resources/application.properties |  16 +-
 .../test-auto-deploy-apps/TST_APP.zip         | Bin 30497 -> 18984 bytes
 .../test-auto-deploy-apps/trackVarsApp.zip    | Bin 11660 -> 11664 bytes
 16 files changed, 1967 insertions(+), 430 deletions(-)
 create mode 100644 customer-work/docs/model-tests.md
 create mode 100644 customer-work/src/main/java/com/customer/work/service/VarUtil.java
 delete mode 100644 customer-work/src/main/java/com/customer/work/service/VarUtils.java
 create mode 100644 customer-work/src/test/java/com/customer/work/service/VarUtilArrayTrackingTest.java
 create mode 100644 customer-work/src/test/java/com/customer/work/service/VarUtilExpressionFunctionsTest.java
 create mode 100644 customer-work/src/test/java/com/customer/work/service/VarUtilMockScopeTest.java
 create mode 100644 customer-work/src/test/java/com/customer/work/service/VarUtilTest.java

diff --git a/customer-work/docs/model-tests.md b/customer-work/docs/model-tests.md
new file mode 100644
index 0000000..5bd80b2
--- /dev/null
+++ b/customer-work/docs/model-tests.md
@@ -0,0 +1,370 @@
+# Model Tests for Flowable Apps
+
+This page describes how to write automated tests for Flowable app models (BPMN processes, CMMN cases) in the `customer-work` module. Model tests run as plain JUnit tests against an in-memory H2 database — no Docker, no running platform needed.
+
+Test data can be provided in three ways:
+
+1. Directly in Java (simple, single-scenario tests)
+2. As JSON parameter files (one scenario per file)
+3. As Excel workbooks (many scenarios as rows; can be edited with Microsoft Excel or LibreOffice Calc)
+
+---
+
+## 1. Project structure
+
+All model-test code and data lives in the `customer-work` module:
+
+```
+customer-work/
+├── src/main/java/com/customer/work/
+│   └── service/                            # custom runtime code used by the models
+│       └── JsonUtils.java                  #   JSON conversion helpers for service tasks
+│
+├── src/test/java/com/customer/work/
+│   ├── config/
+│   │   └── TestConfiguration.java          # test Spring configuration
+│   └── model/                              # the test framework
+│       ├── FlowableModelTest.java          #   @FlowableModelTest meta-annotation
+│       ├── FlowableModelTestUtils.java     #   main utility bean (start, complete, assert, load)
+│       ├── FlowableExcelParser.java        #   reads .xlsx workbooks from the classpath
+│       ├── FlowableExcelMapper.java        #   maps workbook rows to test parameters
+│       ├── FlowableJsonParser.java         #   converts plain test data to model variable types
+│       ├── EmailDto.java                   #   captured email (subject, receivers, content)
+│       ├── TestMailServer.java             #   GreenMail SMTP server for email assertions
+│       ├── TestMailServerExtension.java    #   starts/stops the mail server per test
+│       └── test/                           # the actual test classes
+│           └── ModelTest.java              #   tests for the TST_APP models
+│
+└── src/test/resources/
+    ├── application.properties              # H2 datasource, mail server port, app location
+    ├── test-auto-deploy-apps/
+    │   └── TST_APP.zip                     # the app under test (exported from Design)
+    └── model/test/                         # test data, one directory per model
+        ├── C001/
+        │   └── T001.json                   # task completion payload
+        ├── P001/
+        │   └── initiator.json              # JSON parameter file
+        ├── P002/
+        │   ├── boolean1.json … date.json   # JSON parameter files
+        │   └── p002Test.xlsx               # Excel workbook with test cases
+        └── P005/
+            └── T001.json
+```
+
+Conventions:
+
+- Test data goes to `src/test/resources/model/test/<MODEL>/`, where `<MODEL>` is the short name of the model under test (e.g. `P002` for process `TST_P002`).
+- JSON files are named after the scenario they cover (`boolean1.json`, `initiator.json`); task completion payloads are named after the task (`T001.json`).
+- One Excel workbook per model (`p002Test.xlsx`) holds all data-driven cases for that model.
+- Test classes live in `com.customer.work.model.test`; the framework classes in `com.customer.work.model` normally do not need to be touched when adding new tests.
+
+## 2. How it works
+
+Every test deploys the app under test and starts the model through a generated **wrapper process**:
+
+```
+[Wrapper process <KEY>_T]  →  Call Activity  →  [Process under test <KEY>]
+```
+
+The wrapper is generated at runtime by `FlowableModelTestUtils.createRootTestProcessInstance(testKey, variables)`. This makes the test realistic for models that read or write variables on their **root** process (e.g. via `varutil` with the `root.` prefix), and it allows testing the model's **in/out parameter mappings**:
+
+- Variables passed at the top level are set on the **wrapper (root) process**.
+- The special variable `__IN` (a map) creates **in-mappings** on the call activity: each entry `"name": value` maps `${__IN.name}` to the variable `name` of the called process.
+- The special variable `__OUT` (a map) creates **out-mappings**: each entry `"source": "target"` copies variable `source` of the called process to variable `target` of the root process when the call activity completes.
+
+The method returns the IDs of both instances:
+
+| Key | Content |
+|---|---|
+| `ROOT_PROCESS_ID` | ID of the generated wrapper (root) process instance |
+| `TEST_PROCESS_ID` | ID of the process under test (the call activity child) |
+
+Assertions are usually made against the **historic payload of the root process** (`getHistProcessPayload`), so they see both the root variables and everything mapped out of the model under test.
+
+### Test infrastructure
+
+| Piece | Purpose |
+|---|---|
+| `@FlowableModelTest` | Meta-annotation: boots the Spring context with all Flowable engine test extensions, makes each test `@Transactional` (automatic rollback) and starts the test mail server |
+| `FlowableModelTestUtils` | The main utility bean: start instances, complete tasks, execute timers, load test data, assert emails / audit records |
+| `FlowableExcelParser` / `FlowableExcelMapper` | Read Excel workbooks from the classpath and turn each data row into test parameters |
+| `TestMailServer` (GreenMail) | Captures emails sent by the model; configured via `flowable.mail.server.host/port` in `src/test/resources/application.properties` |
+
+### App deployment
+
+The app under test must be available as a zip in `src/test/resources/test-auto-deploy-apps/` (e.g. `TST_APP.zip`). It is auto-deployed at context start via:
+
+```properties
+flowable.app.resource-location=classpath*:/test-auto-deploy-apps/
+```
+
+To refresh the zip from a running Flowable Design, temporarily enable the `exportApp` test (remove `@Disabled`) and run it once:
+
+```java
+flowableModelTest.exportApp("http://localhost:8106", "myWorkspace", "TST_APP", "admin", "test");
+```
+
+---
+
+## 3. Writing a model test class
+
+Annotate the class with `@FlowableModelTest` and inject `FlowableModelTestUtils`:
+
+```java
+@FlowableModelTest
+public class ModelTest {
+
+    @Autowired
+    protected FlowableModelTestUtils flowableModelTest;
+
+    @Test
+    public void p005HappyPathTest() {
+        // Start TST_P005 wrapped in a root process, no start variables
+        ObjectNode processIds = flowableModelTest.createRootTestProcessInstance("TST_P005", flowableModelTest.emptyMap());
+
+        // Work on the open user task
+        flowableModelTest.claimOpenTask("TST_P005_T001", "admin");
+        flowableModelTest.completeOpenTask("TST_P005_T001",
+                flowableModelTest.loadObjectNodeFromResources("model/test/P005/T001.json"), null);
+
+        // Assert against the historic root process payload
+        Map<String, Object> rootPayload = flowableModelTest.getHistProcessPayload(
+                processIds.get(FlowableModelTestUtils.ROOT_PROCESS_ID).asText());
+        Assertions.assertThat(rootPayload.get("dataEntry")).isEqualTo("my root text");
+    }
+}
+```
+
+### Frequently used utility methods
+
+| Method | Purpose |
+|---|---|
+| `createRootTestProcessInstance(key, vars)` | Deploy wrapper + start the model under test, returns the two instance IDs |
+| `startCaseInstance(key, vars)` | Start a CMMN case directly |
+| `setTestAuthenticatedUser(userId, tenantId, groups...)` | Set the authenticated user for subsequent engine calls |
+| `claimOpenTask(taskKey, userId)` / `completeOpenTask(taskKey, vars, outcome)` | Claim / complete the single open task with the given task definition key. `vars` may be flat (`"a.b": 1`) — existing task variables are merged automatically |
+| `executeTimer(processId)` | Fire the active timer job of the given process instance |
+| `getHistProcessPayload(id)` / `getRuntimeCasePayload(id)` / `getHistoryCasePayload(id)` | Read variables for assertions |
+| `getMailList()` | All emails captured by the test mail server |
+| `getAuditTrail()` | All audit records |
+| `loadObjectNodeFromResources(path)` / `loadTestVarsFromResources(path)` | Load JSON test data from `src/test/resources` (see below) |
+| `getJsonArgumentsFromExcel(path)` / `getObjArgumentsFromExcel(path)` | Excel rows as JUnit parameterized-test arguments (see below) |
+| `testJsonExcelRow(path, row)` / `testObjExcelRow(path, row)` | Run one Excel row: start, fire timers, assert payload / audit / email counts |
+
+### Running the tests
+
+```bash
+cd C-2025.2
+./mvnw test -pl customer-work -Dtest=ModelTest    # one class
+./mvnw test -pl customer-work                     # whole module
+```
+
+---
+
+## 4. JSON parameter files
+
+JSON files define the start parameters for one test scenario. They live under `src/test/resources/model/test/<MODEL>/` and are loaded with `loadTestVarsFromResources(path)`.
+
+### Structure
+
+All parameters must be declared **explicitly** in one of three top-level blocks:
+
+| Block | Meaning |
+|---|---|
+| `__ROOT` | Variables set on the root (wrapper) process |
+| `__IN` | In-mappings of the call activity: `"name": value` passes the value as variable `name` into the model under test |
+| `__OUT` | Out-mappings: `"source": "target"` copies variable `source` of the model to variable `target` of the root process on completion |
+
+Every block is optional, but **any other top-level field fails the test** with:
+
+```
+IllegalArgumentException: Implicit parameter 'param' in model/test/P002/boolean1.json:
+parameters must be declared explicitly inside __ROOT, __IN or __OUT
+```
+
+Keys inside `__ROOT` must not start with `__`.
+
+### Example: `model/test/P002/boolean1.json`
+
+```json
+{
+  "__ROOT": {
+    "param": true
+  },
+  "__IN": {
+    "param": false
+  },
+  "__OUT": {
+    "result": "out"
+  }
+}
+```
+
+This sets `param = true` on the root process, passes `param = false` into `TST_P002`, and copies the model's `result` variable to the root variable `out` when the model completes.
+
+### Example: using JSON files in a parameterized test
+
+```java
+private Stream<Arguments> p002TestData() {
+    return Stream.of(
+            Arguments.of("model/test/P002/boolean1.json", true, false),
+            Arguments.of("model/test/P002/int.json", 123, 456)
+    );
+}
+
+@ParameterizedTest
+@MethodSource("p002TestData")
+public void p002Test(String path, Object result, Object out) {
+    ObjectNode processIds = flowableModelTest.createRootTestProcessInstance("TST_P002",
+            flowableModelTest.loadTestVarsFromResources(path));
+    Map<String, Object> rootPayload = flowableModelTest.getHistProcessPayload(
+            processIds.get(FlowableModelTestUtils.ROOT_PROCESS_ID).asText());
+
+    Assertions.assertThat(rootPayload.get("result")).isEqualTo(result);
+    Assertions.assertThat(rootPayload.get("out")).isEqualTo(out);
+}
+```
+
+---
+
+## 5. Excel test workbooks
+
+For data-driven testing of many scenarios, define one workbook per model, e.g. `src/test/resources/model/test/P002/p002Test.xlsx`. Both **Microsoft Excel** and **LibreOffice Calc** can be used to create and edit the file (`.xlsx` format).
+
+Each **sheet** is a group of test cases, each **data row** is one test case that starts the model, optionally fires timers, and asserts the results.
+
+### Sheet layout
+
+| Row | Content |
+|---|---|
+| 1 | **Path** of each column's value (see path notation below) |
+| 2 | **Type** of each column: `String`, `Boolean`, `Integer`, `Long`, `Double`, `Date` |
+| 3+ | One test case per row |
+
+Parsing rules:
+
+- The column count is taken from row 1: columns are read from the first cell up to the **first empty header cell**.
+- Rows are read until the **first completely empty row** — everything below is ignored (useful for comments or temporarily disabled cases).
+- **Empty cells are skipped** — the variable / check is simply not used for that row.
+- Formulas are evaluated (e.g. `=TRUE()`); the displayed value is what counts.
+
+### Path notation (row 1)
+
+The path decides where the value goes. Nested objects use `.`, array elements use `[index]`:
+
+| Path prefix | Meaning |
+|---|---|
+| `root.<name>` | Variable on the root process (like `__ROOT` in JSON) |
+| `in.<name>` | In-mapping into the model (like `__IN`) |
+| `out.<source>` | Out-mapping; the cell value is the **target** variable name (like `__OUT`) |
+| `id` | **Required.** Process definition key of the model under test, e.g. `TST_P002` |
+| `timer` | Number of timer jobs to fire after start (Integer) |
+| `test.<name>` | Expected value of variable `<name>` in the root process payload after the run |
+| `audit` | Expected total number of audit records (Integer) |
+| `email` | Expected total number of sent emails (Integer) |
+
+Nested examples:
+
+| Header | Effect |
+|---|---|
+| `root.param` | Root variable `param` |
+| `root.param[0]`, `root.param[1]` | Root variable `param` as array with two elements |
+| `root.items[1].name` | Root variable `items`, array whose second element is an object with field `name` |
+| `test.result[0]` | Asserts the first element of array variable `result` |
+
+Array elements that are skipped (e.g. only `[1]` is filled) are padded with empty objects, because Flowable cannot store `null` list elements.
+
+### Special cell values
+
+| Value | In input columns (`root.`, `in.`, `out.`) | In `test.` columns |
+|---|---|---|
+| *(empty cell)* | Variable not set | No check |
+| `__NULL` | Variable set to JSON `null` | No check (a null expectation matches anything) |
+| `__N_A` | – | Asserts the variable/field is **absent or null** |
+| `__EMPTY` | Empty string `""` (type `String` only) | Expects `""` |
+| `__BLANK` | Single space `" "` (type `String` only) | Expects `" "` |
+
+### Types (row 2)
+
+| Type | Cell content |
+|---|---|
+| `String` | Any text |
+| `Boolean` | `TRUE` / `FALSE` (or a formula like `=TRUE()`) |
+| `Integer`, `Long`, `Double` | Numeric value |
+| `Date` | A date cell displayed as `yyyy-MM-dd` or `yyyy-MM-dd HH:mm:ss`. The displayed (local) date is interpreted as **UTC** |
+
+### Example sheet
+
+| | A | B | C | D | E | F | G | H |
+|---|---|---|---|---|---|---|---|---|
+| **1** | `root.nr` | `root.param` | `in.param` | `out.result` | `id` | `timer` | `test.result` | `test.outResult` |
+| **2** | `String` | `String` | `String` | `String` | `String` | `Integer` | `String` | `String` |
+| **3** | 11 | | | | TST_P002 | | | |
+| **4** | 12 | hello root | hello | outResult | TST_P002 | 1 | hello root | hello |
+| **5** | 13 | | hello | outResult | TST_P002 | 0 | `__N_A` | `__NULL` |
+
+- Row 3: starts `TST_P002` with no parameters and no checks (smoke test).
+- Row 4: sets root and in parameters, maps `result` out to `outResult`, fires one timer, then asserts `result == "hello root"` and `outResult == "hello"`.
+- Row 5: no root param; asserts that `result` was **not** set (`__N_A`) and skips the `outResult` check.
+
+Tip: a column like `root.nr` is a handy row number — it appears in the test log line of every row, which makes failures easy to locate.
+
+### How assertions work
+
+After the run, the expected values from the `test.` columns are compared as a **subset** against the historic root process payload: every expected field must exist with the same (string-compared) value; extra variables in the payload are ignored. On failure the test prints both sides:
+
+```
+test : {"result":"hello root","outResult":"hello"}
+root : {"nr":"12","param":"hello root", ...}
+```
+
+If `audit` / `email` columns are present, the total counts are asserted as well.
+
+### Wiring the workbook into JUnit
+
+Every data row of every sheet becomes one JUnit test invocation:
+
+```java
+private Stream<Arguments> p002ExcelTestData() {
+    return flowableModelTest.getJsonArgumentsFromExcel("model/test/P002/p002Test.xlsx");
+}
+
+@ParameterizedTest
+@MethodSource("p002ExcelTestData")
+public void p002ExcelTest(String path, JsonNode argument) {
+    flowableModelTest.testJsonExcelRow(path, argument);
+}
+```
+
+The `Obj` variant works with plain Java maps and additionally returns a result map that can drive detailed email / audit assertions (they only run for rows where the `email` / `audit` count is > 0):
+
+```java
+private Stream<Arguments> p002ExcelTestData2() {
+    return flowableModelTest.getObjArgumentsFromExcel("model/test/P002/p002Test.xlsx");
+}
+
+@ParameterizedTest
+@MethodSource("p002ExcelTestData2")
+public void p002ExcelTest2(String path, Map<String, Object> argument) {
+    Map<String, Object> result = flowableModelTest.testObjExcelRow(path, argument);
+    flowableModelTest.checkAndAssertEmail(result, 1,
+            "Email", "Test", "test@flowable.com");
+    flowableModelTest.checkAndAssertAuditRecord(result, 1,
+            "Audit record", "TST_P002 Audit trail entry", "system", null);
+}
+```
+
+---
+
+## 6. Troubleshooting
+
+| Symptom | Cause / fix |
+|---|---|
+| `Implicit parameter 'x' in <file>` | A top-level field outside `__ROOT` / `__IN` / `__OUT` in a JSON parameter file — move it into the right block |
+| `Resource not found: <path>` | Path is relative to `src/test/resources` and is loaded from the classpath — check spelling and location |
+| `Column 'id' missing in row of <file>` | The Excel sheet has no `id` column, or the cell is empty for that row |
+| `No open task with key X found` | The model did not reach the expected user task — or more than one task with that key is open |
+| `No active timer` | The `timer` count in the row is higher than the number of timer jobs the model actually creates |
+| `Missing ']' in path` / `Invalid array index in path` | Malformed header path in row 1, e.g. `root.param[0` or `root.param[a]` |
+| `Variable type not supported: X` | Typo in row 2 — allowed: `String`, `Boolean`, `Integer`, `Long`, `Double`, `Date` |
+| Subset assertion fails with `test:` / `root:` output | Compare both printed JSON documents; remember values are compared as strings and `__N_A` requires absence |
diff --git a/customer-work/src/main/java/com/customer/work/SecurityHttpBasicConfiguration.java b/customer-work/src/main/java/com/customer/work/SecurityHttpBasicConfiguration.java
index f304862..e36ea8f 100644
--- a/customer-work/src/main/java/com/customer/work/SecurityHttpBasicConfiguration.java
+++ b/customer-work/src/main/java/com/customer/work/SecurityHttpBasicConfiguration.java
@@ -30,7 +30,7 @@ public class SecurityHttpBasicConfiguration {
     @Order(10)
     public SecurityFilterChain basicDefaultSecurity(HttpSecurity http, ObjectProvider<FlowableHttpSecurityCustomizer> httpSecurityCustomizers) throws Exception {
         for (FlowableHttpSecurityCustomizer customizer : httpSecurityCustomizers.orderedStream()
-                .toList()) {
+                .collect(Collectors.toList())) {
             customizer.customize(http);
         }
 
diff --git a/customer-work/src/main/java/com/customer/work/service/VarUtil.java b/customer-work/src/main/java/com/customer/work/service/VarUtil.java
new file mode 100644
index 0000000..80fb791
--- /dev/null
+++ b/customer-work/src/main/java/com/customer/work/service/VarUtil.java
@@ -0,0 +1,741 @@
+package com.customer.work.service;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.SerializationFeature;
+import com.fasterxml.jackson.databind.node.ArrayNode;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
+import org.flowable.cmmn.api.CmmnRuntimeService;
+import org.flowable.cmmn.api.runtime.CaseInstance;
+import org.flowable.cmmn.api.runtime.PlanItemInstance;
+import org.flowable.cmmn.engine.impl.persistence.entity.CaseInstanceEntity;
+import org.flowable.engine.RuntimeService;
+import org.flowable.engine.delegate.DelegateExecution;
+import org.flowable.engine.impl.persistence.entity.ExecutionEntity;
+import org.flowable.engine.runtime.Execution;
+import org.flowable.engine.runtime.ProcessInstance;
+import org.flowable.variable.api.delegate.VariableScope;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * General-purpose Flowable variable utility bean for tracking variable changes
+ * and for null-safe variable access.
+ * Usable in BPMN process and CMMN case backend expressions:
+ *   ${varutil.trackVars('root.snapshot', 'order.customer.name,order.total,status')}
+ *   ${varutil.trackVars(execution, 'root.snapshot', 'status')}          — BPMN, explicit scope
+ *   ${varutil.trackVars(planItemInstance, 'root.snapshot', 'status')}   — CMMN, explicit scope
+ *   ${varutil.get(execution, 'orders[2].customer.name')}                — null-safe read
+ * Variable paths use dot notation; a leading "root." prefix addresses the root
+ * instance of a nested case/process hierarchy. A "[]" in a path expands over all
+ * elements of the JSON/List array at that point, e.g. "status[]" (simple types),
+ * "orders[].name" (object fields) or "orders[].items[].qty" (nested arrays).
+ * A path that just names an array ("status", "orders[].items") tracks all its
+ * entries as well, as if "[]" were appended.
+ * The get/getOrDefault/exists/isEmpty/isNotEmpty/equals/notEquals/contains/
+ * containsAny/lowerThan(OrEquals)/greaterThan(OrEquals)/base64 methods are
+ * null-safe, path-based counterparts of the Flowable var: expression functions.
+ */
+@Component("varUtil")
+public class VarUtil {
+
+    private static final Logger LOGGER = LoggerFactory.getLogger(VarUtil.class);
+
+    private static final ObjectMapper MAPPER;
+    static {
+        MAPPER = new ObjectMapper();
+        MAPPER.registerModule(new JavaTimeModule());
+        MAPPER.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
+    }
+
+    @Autowired
+    private RuntimeService runtimeService;
+
+    @Autowired
+    private CmmnRuntimeService cmmnRuntimeService;
+
+    // -------------------------------------------------------------------------
+    // Public API — called from Flowable expressions
+    // -------------------------------------------------------------------------
+
+    /**
+     * Checks which of the given comma-separated variable paths changed since the
+     * last call and returns a JSON array describing each change.
+     * Example call:
+     *   ${varutil.trackVars(self, 'root.snapshot', 'root.status, status')}
+     * Example return value:
+     *   [{"path":"root.status","oldValue":"a","newValue":"b"}, {"path":"status","oldValue":"c","newValue":"d"}]
+     * Paths containing "[]" are expanded per array element (e.g. "status[]",
+     * "orders[].name"); changes are then reported per concrete index, such as
+     * {"path":"orders[2].name",...}. A path that resolves to an array without an
+     * explicit "[]" is expanded the same way. Elements added since the last call
+     * are reported with oldValue null, removed elements with newValue null.
+     */
+    public ArrayNode trackVars(VariableScope currentScope, String snapshotPath, String variablePathsCsv) {
+
+        // Reject blank parameters early — report "no changes" instead of failing,
+        // so a misconfigured expression cannot break the surrounding process/case.
+        if (snapshotPath == null || snapshotPath.isBlank() || variablePathsCsv == null || variablePathsCsv.isBlank()) {
+            LOGGER.debug("{}.trackVars: empty parameters", getClass().getName());
+            return MAPPER.createArrayNode();
+        }
+
+        // Without a resolvable scope there is nothing to read from or write to.
+        if (currentScope == null) {
+            LOGGER.debug("{}.trackVars: currentScope not found", getClass().getName());
+            return MAPPER.createArrayNode();
+        }
+
+        // Split the CSV into individual variable paths, dropping blanks and whitespace.
+        List<String> paths = Arrays.stream(variablePathsCsv.split(","))
+                .map(String::trim).filter(s -> !s.isEmpty()).toList();
+
+        // Load the previous values (persisted as a JSON string variable at
+        // snapshotPath) to compare the current values against.
+        Map<String, JsonNode> oldSnapshot = loadSnapshot(currentScope, snapshotPath);
+        Map<String, JsonNode> newSnapshot = new HashMap<>();
+        ArrayNode changes = MAPPER.createArrayNode();
+
+        // For every tracked path: expand "[]" over the current array elements,
+        // then read each concrete value, normalize it so it compares consistently
+        // with the reloaded snapshot, and record a change entry whenever old != new.
+        for (String path : paths) {
+            for (String concretePath : expandArrayPath(currentScope, path)) {
+                JsonNode newValue = normalize(toJson(readVariableFromPath(currentScope, concretePath)));
+                newSnapshot.put(concretePath, newValue);
+
+                JsonNode oldValue = oldSnapshot.getOrDefault(concretePath, MAPPER.nullNode());
+                if (!oldValue.equals(newValue)) {
+                    addChange(changes, concretePath, oldValue, newValue);
+                }
+            }
+
+            // Old snapshot entries matching the spec but no longer produced by the
+            // expansion belong to removed array elements (or a value that changed
+            // shape between scalar and array) — report them as changes to null and
+            // let them drop out of the new snapshot.
+            java.util.regex.Pattern pattern = arraySpecPattern(path);
+            for (Map.Entry<String, JsonNode> old : oldSnapshot.entrySet()) {
+                if (pattern.matcher(old.getKey()).matches()
+                        && !newSnapshot.containsKey(old.getKey())
+                        && !old.getValue().isNull()) {
+                    addChange(changes, old.getKey(), old.getValue(), MAPPER.nullNode());
+                }
+            }
+        }
+
+        // Persist the current values as the reference snapshot for the next call.
+        saveSnapshot(currentScope, snapshotPath, newSnapshot);
+
+        return changes;
+    }
+
+    // -------------------------------------------------------------------------
+    // Null-safe variable functions — path-based counterparts of the Flowable
+    // var: expression functions (var:get, var:exists, ...). All accept the same
+    // path syntax as trackVars and never throw on unresolvable paths.
+    // -------------------------------------------------------------------------
+
+    /**
+     * Null-safe read: returns the value at the path, or null when any part of
+     * the path cannot be resolved (missing variable, null intermediate, index
+     * out of bounds). A path with an explicit "[]" returns the flattened List
+     * of entry values, e.g. "orders[].name" -> ["n1", "n2"].
+     */
+    public Object get(VariableScope scope, String path) {
+        return resolve(scope, path);
+    }
+
+    /** Like {@link #get}, but returns {@code defaultValue} instead of null. */
+    public Object getOrDefault(VariableScope scope, String path, Object defaultValue) {
+        Object value = resolve(scope, path);
+        return value != null ? value : defaultValue;
+    }
+
+    /** True when the path resolves to a non-null value. */
+    public boolean exists(VariableScope scope, String path) {
+        return resolve(scope, path) != null;
+    }
+
+    /**
+     * True when the path resolves to null, an empty String, or an empty
+     * List/Map/array/JSON container.
+     */
+    public boolean isEmpty(VariableScope scope, String path) {
+        return isEmptyValue(resolve(scope, path));
+    }
+
+    /** Inverse of {@link #isEmpty}. */
+    public boolean isNotEmpty(VariableScope scope, String path) {
+        return !isEmpty(scope, path);
+    }
+
+    /**
+     * True when the value at the path equals the given value. Both sides are
+     * normalized to JSON before comparing, so a Long 5 equals an Integer 5 and
+     * a JsonNode field equals its plain Java counterpart. A null value only
+     * equals an unresolvable/null path.
+     */
+    public boolean equals(VariableScope scope, String path, Object value) {
+        return jsonEquals(resolve(scope, path), value);
+    }
+
+    /** Inverse of {@link #equals(VariableScope, String, Object)}. */
+    public boolean notEquals(VariableScope scope, String path, Object value) {
+        return !equals(scope, path, value);
+    }
+
+    /**
+     * True when the value at the path contains ALL given values: substring for
+     * Strings, element containment (JSON-normalized) for List/array/JSON array.
+     * False for null or any other value type.
+     */
+    public boolean contains(VariableScope scope, String path, Object... values) {
+        Object container = resolve(scope, path);
+        if (container == null || values == null || values.length == 0) return false;
+        for (Object value : values) {
+            if (!containsValue(container, value)) return false;
+        }
+        return true;
+    }
+
+    /** Like {@link #contains}, but true when ANY of the given values is contained. */
+    public boolean containsAny(VariableScope scope, String path, Object... values) {
+        Object container = resolve(scope, path);
+        if (container == null || values == null) return false;
+        for (Object value : values) {
+            if (containsValue(container, value)) return true;
+        }
+        return false;
+    }
+
+    /** True when the numeric value at the path is lower than the given number. */
+    public boolean lowerThan(VariableScope scope, String path, Object value) {
+        Integer cmp = compareNumeric(resolve(scope, path), value);
+        return cmp != null && cmp < 0;
+    }
+
+    /** True when the numeric value at the path is lower than or equal to the given number. */
+    public boolean lowerThanOrEquals(VariableScope scope, String path, Object value) {
+        Integer cmp = compareNumeric(resolve(scope, path), value);
+        return cmp != null && cmp <= 0;
+    }
+
+    /** True when the numeric value at the path is greater than the given number. */
+    public boolean greaterThan(VariableScope scope, String path, Object value) {
+        Integer cmp = compareNumeric(resolve(scope, path), value);
+        return cmp != null && cmp > 0;
+    }
+
+    /** True when the numeric value at the path is greater than or equal to the given number. */
+    public boolean greaterThanOrEquals(VariableScope scope, String path, Object value) {
+        Integer cmp = compareNumeric(resolve(scope, path), value);
+        return cmp != null && cmp >= 0;
+    }
+
+    /**
+     * Base64-encodes the String (UTF-8) or byte[] value at the path; null for
+     * anything else.
+     */
+    public String base64(VariableScope scope, String path) {
+        Object value = resolve(scope, path);
+        if (value instanceof byte[] bytes) return java.util.Base64.getEncoder().encodeToString(bytes);
+        if (value instanceof String s)
+            return java.util.Base64.getEncoder().encodeToString(s.getBytes(java.nio.charset.StandardCharsets.UTF_8));
+        return null;
+    }
+
+    /**
+     * Resolves a path to its value. A path with an explicit "[]" resolves to
+     * the flattened List of the expanded entry values; unlike trackVars, a bare
+     * array name is NOT expanded — it resolves to the array itself.
+     */
+    private Object resolve(VariableScope scope, String path) {
+        if (scope == null || path == null || path.isBlank()) return null;
+        String trimmed = path.trim();
+        if (trimmed.contains("[]")) {
+            List<Object> values = new java.util.ArrayList<>();
+            for (String concretePath : expandArrayPath(scope, trimmed)) {
+                values.add(readVariableFromPath(scope, concretePath));
+            }
+            return values;
+        }
+        return readVariableFromPath(scope, trimmed);
+    }
+
+    // -------------------------------------------------------------------------
+    // Path resolution
+    // -------------------------------------------------------------------------
+
+    /**
+     * Expands every "[]" in a path over the elements of the array currently found
+     * at that point, e.g. "orders[].name" with two orders becomes
+     * ["orders[0].name", "orders[1].name"]. Works recursively, so nested arrays
+     * ("a[].b[]", "a[][]") expand to all combinations. A path without "[]" that
+     * resolves to an array is expanded as if "[]" were appended; other paths are
+     * returned as-is. A "[]" that does not hit an array expands to nothing.
+     */
+    private List<String> expandArrayPath(VariableScope scope, String path) {
+        int idx = path.indexOf("[]");
+        if (idx < 0) {
+            // Bare path: when it resolves to an array, track all its entries as
+            // if "[]" were appended (recursing handles arrays of arrays).
+            Object value = readVariableFromPath(scope, path);
+            if (!isArray(value)) return List.of(path);
+            List<String> result = new java.util.ArrayList<>();
+            for (int i = 0; i < arraySize(value); i++) {
+                result.addAll(expandArrayPath(scope, path + "[" + i + "]"));
+            }
+            return result;
+        }
+        String prefix = path.substring(0, idx);
+        String suffix = path.substring(idx + 2);
+
+        int size = arraySize(readVariableFromPath(scope, prefix));
+        List<String> result = new java.util.ArrayList<>();
+        for (int i = 0; i < size; i++) {
+            result.addAll(expandArrayPath(scope, prefix + "[" + i + "]" + suffix));
+        }
+        return result;
+    }
+
+    /**
+     * Builds a regex matching all concrete expansions of a path spec,
+     * e.g. "orders[].name" matches "orders[0].name", "orders[12].name", ...
+     * The trailing index group also covers bare-array auto-expansion, so "status"
+     * matches "status", "status[3]" and "status[0][1]". Used to find snapshot
+     * entries of elements that no longer exist.
+     */
+    private static java.util.regex.Pattern arraySpecPattern(String spec) {
+        StringBuilder regex = new StringBuilder();
+        for (String literal : spec.split("\\[\\]", -1)) {
+            if (regex.length() > 0) regex.append("\\[\\d+\\]");
+            regex.append(java.util.regex.Pattern.quote(literal));
+        }
+        regex.append("(\\[\\d+\\])*");
+        return java.util.regex.Pattern.compile(regex.toString());
+    }
+
+    /** True for the container types expanded by "[]": List, Object[] or JSON array. */
+    private static boolean isArray(Object obj) {
+        return obj instanceof List<?> || obj instanceof Object[]
+                || (obj instanceof JsonNode jn && jn.isArray());
+    }
+
+    /** Returns the element count of a List, Object[] or JSON array, else 0. */
+    private static int arraySize(Object obj) {
+        if (obj instanceof List<?> list) return list.size();
+        if (obj instanceof Object[] arr) return arr.length;
+        if (obj instanceof JsonNode jn && jn.isArray()) return jn.size();
+        return 0;
+    }
+
+    /**
+     * Reads a value via a dot-notation path, e.g. "order.customer.name".
+     * The first segment names a Flowable variable; the remaining segments navigate
+     * into that value (maps, lists/arrays by index, JsonNodes, POJOs — see
+     * {@link #getNestedVariable}). Segments may carry "[n]" index suffixes to
+     * address array elements, e.g. "orders[0].name" or "matrix[1][2]".
+     * Returns null when any segment cannot be resolved.
+     */
+    private Object readVariableFromPath(VariableScope scope, String path) {
+        String[] segments = path.split("\\.", -1);
+        if (segments.length < 1) return null;
+
+        // A leading "root." switches to the root instance of the surrounding
+        // case/process hierarchy before resolving the variable.
+        int startIndex = 0;
+        if ("root".equals(segments[0])) {
+            if (segments.length < 2) return null;
+            startIndex = 1;
+            scope = getRootScope(scope);
+        }
+        if (scope == null) return null;
+
+        // Read the top-level variable, then walk the remaining segments into it.
+        String first = segments[startIndex];
+        int bracket = first.indexOf('[');
+        Object currentValue = scope.getVariable(bracket < 0 ? first : first.substring(0, bracket));
+        if (bracket >= 0) currentValue = applyIndices(currentValue, first.substring(bracket));
+
+        for (int i = startIndex + 1; i < segments.length; i++) {
+            if (currentValue == null) return null;
+            String segment = segments[i];
+            bracket = segment.indexOf('[');
+            if (bracket < 0) {
+                currentValue = getNestedVariable(currentValue, segment);
+            } else {
+                if (bracket > 0) currentValue = getNestedVariable(currentValue, segment.substring(0, bracket));
+                currentValue = applyIndices(currentValue, segment.substring(bracket));
+            }
+        }
+        return currentValue;
+    }
+
+    /** Applies a chain of "[n]" index suffixes ("[0]", "[1][2]", ...) to a value. */
+    private static Object applyIndices(Object value, String indices) {
+        java.util.regex.Matcher m = INDEX_PATTERN.matcher(indices);
+        while (m.find()) {
+            if (value == null) return null;
+            value = getElement(value, Integer.parseInt(m.group(1)));
+        }
+        return value;
+    }
+
+    private static final java.util.regex.Pattern INDEX_PATTERN =
+            java.util.regex.Pattern.compile("\\[(\\d+)\\]");
+
+    /** Returns element i of a List, Object[] or JSON array (scalars unwrapped), else null. */
+    private static Object getElement(Object obj, int i) {
+        if (obj instanceof List<?> list) return i >= 0 && i < list.size() ? list.get(i) : null;
+        if (obj instanceof Object[] arr) return i >= 0 && i < arr.length ? arr[i] : null;
+        if (obj instanceof JsonNode jn && jn.isArray()) return unwrapJson(jn.get(i));
+        return null;
+    }
+
+    /**
+     * Writes a value via a dot-notation path (same syntax as
+     * {@link #readVariableFromPath}). A single-segment path sets a plain Flowable
+     * variable; a nested path mutates the container inside the top-level variable
+     * and writes that variable back so the engine persists the change.
+     */
+    private void writeVariableToPath(VariableScope scope, String path, Object value) {
+        String[] segments = path.split("\\.", -1);
+        if (segments.length < 1) return;
+
+        // A leading "root." redirects the write to the root instance of the
+        // surrounding case/process hierarchy.
+        VariableScope targetScope;
+        String[] varSegments;
+        if ("root".equals(segments[0])) {
+            if (segments.length < 2) return;
+            targetScope = getRootScope(scope);
+            varSegments = Arrays.copyOfRange(segments, 1, segments.length);
+        } else {
+            targetScope = scope;
+            varSegments = segments;
+        }
+        if (targetScope == null) return;
+
+        if (varSegments.length == 1) {
+            targetScope.setVariable(varSegments[0], value);
+            return;
+        }
+
+        // Nested path: read the top-level variable, navigate to the parent node,
+        // mutate it in-place, then write the top-level variable back.
+        String topVar = varSegments[0];
+        Object topValue = targetScope.getVariable(topVar);
+
+        Object parent = topValue;
+        for (int i = 1; i < varSegments.length - 1; i++) {
+            if (parent == null) {
+                LOGGER.warn("varutil.writeVariableToPath: null at '{}' in path '{}'", varSegments[i - 1], path);
+                return;
+            }
+            parent = getNestedVariable(parent, varSegments[i]);
+        }
+
+        if (!setNestedValue(parent, varSegments[varSegments.length - 1], value, path)) return;
+        targetScope.setVariable(topVar, topValue);
+    }
+
+    /**
+     * Sets one key on a mutable container (Map or ObjectNode). Anything else —
+     * including POJOs, which are read-only for this bean — is rejected with a
+     * warning so a bad path never breaks the calling expression.
+     */
+    @SuppressWarnings("unchecked")
+    private boolean setNestedValue(Object parent, String key, Object value, String path) {
+        if (parent instanceof Map map) {
+            map.put(key, value);
+            return true;
+        }
+        if (parent instanceof ObjectNode on) {
+            on.set(key, toJson(value));
+            return true;
+        }
+        LOGGER.warn("varutil.writeVariableToPath: cannot set '{}' on {} in path '{}'",
+                key, parent == null ? "null" : parent.getClass().getName(), path);
+        return false;
+    }
+
+    // -------------------------------------------------------------------------
+    // Scope resolution
+    // -------------------------------------------------------------------------
+
+    /**
+     * Climbs from the given scope to the root VariableScope of the surrounding
+     * case/process hierarchy, following call-activity parents (BPMN) and
+     * parent/callback links (CMMN) across engine boundaries.
+     */
+    private VariableScope getRootScope(VariableScope scope) {
+        if (scope instanceof DelegateExecution ex) return findBpmnRootScope(ex.getProcessInstanceId());
+        if (scope instanceof PlanItemInstance pii) return findCmmnRootScope(pii.getCaseInstanceId());
+        if (scope instanceof CaseInstance ci) return findCmmnRootScope(ci.getId());
+        return null;
+    }
+
+    /**
+     * Finds the root scope starting from a BPMN process instance:
+     * 1. started by a call activity → recurse into the calling process instance,
+     * 2. started from a CMMN plan item (callback) → continue climbing in the case,
+     * 3. otherwise this process instance is itself the root.
+     * NOTE: the returned object is a detached query result used as VariableScope;
+     * its variable access only works because expression evaluation runs inside an
+     * active Flowable command context.
+     */
+    private VariableScope findBpmnRootScope(String processInstanceId) {
+        if (processInstanceId == null || runtimeService == null) return null;
+        try {
+            Execution piExec = runtimeService.createExecutionQuery()
+                    .executionId(processInstanceId).singleResult();
+            if (piExec != null && piExec.getSuperExecutionId() != null) {
+                Execution superExec = runtimeService.createExecutionQuery()
+                        .executionId(piExec.getSuperExecutionId()).singleResult();
+                if (superExec != null)
+                    return findBpmnRootScope(superExec.getProcessInstanceId());
+            }
+            ProcessInstance pi = runtimeService.createProcessInstanceQuery()
+                    .processInstanceId(processInstanceId).singleResult();
+            if (pi != null && pi.getCallbackType() != null && pi.getCallbackId() != null
+                    && cmmnRuntimeService != null) {
+                PlanItemInstance planItem = cmmnRuntimeService.createPlanItemInstanceQuery()
+                        .planItemInstanceId(pi.getCallbackId()).singleResult();
+                if (planItem != null)
+                    return findCmmnRootScope(planItem.getCaseInstanceId());
+            }
+            return (ExecutionEntity) piExec;  // root: ExecutionEntity implements VariableScope
+        } catch (Exception e) {
+            LOGGER.debug("{}.findBpmnRootScope: BPMN root scope climb failed: {}", getClass().getName(), e.getMessage());
+            return null;
+        }
+    }
+
+    /**
+     * Finds the root scope starting from a CMMN case instance:
+     * 1. sub-case → recurse into the parent case,
+     * 2. started from a BPMN call/task (callback) → continue climbing in the process,
+     * 3. otherwise this case instance is itself the root.
+     * Same detached-query-result caveat as {@link #findBpmnRootScope}.
+     */
+    private VariableScope findCmmnRootScope(String caseInstanceId) {
+        if (caseInstanceId == null || cmmnRuntimeService == null) return null;
+        try {
+            CaseInstance ci = cmmnRuntimeService.createCaseInstanceQuery()
+                    .caseInstanceId(caseInstanceId).singleResult();
+            if (ci == null) return null;
+            if (ci.getParentId() != null)
+                return findCmmnRootScope(ci.getParentId());
+            if (ci.getCallbackType() != null && ci.getCallbackId() != null
+                    && runtimeService != null) {
+                Execution callbackExec = runtimeService.createExecutionQuery()
+                        .executionId(ci.getCallbackId()).singleResult();
+                if (callbackExec != null)
+                    return findBpmnRootScope(callbackExec.getProcessInstanceId());
+            }
+            return (CaseInstanceEntity) ci;  // root: CaseInstanceEntity implements VariableScope
+        } catch (Exception e) {
+            LOGGER.debug("{}.findCmmnRootScope: CMMN root scope climb failed: {}", getClass().getName(), e.getMessage());
+            return null;
+        }
+    }
+
+    /**
+     * Resolves one path segment against a value: list/array index, map key,
+     * JsonNode field (scalars are unwrapped to plain Java values), and finally
+     * POJO access via getX()/isX() getters or a declared field.
+     */
+    private static Object getNestedVariable(Object obj, String segment) {
+        // Empty segments (e.g. from "a..b" or a trailing dot) cannot address anything.
+        if (segment == null || segment.isEmpty()) return null;
+
+        // Lists and arrays are addressed by numeric index, e.g. "items.0.name".
+        if (obj instanceof List<?> list) {
+            try {
+                int i = Integer.parseInt(segment);
+                return i >= 0 && i < list.size() ? list.get(i) : null;
+            } catch (NumberFormatException ignored) {}
+        }
+        if (obj instanceof Object[] arr) {
+            try {
+                int i = Integer.parseInt(segment);
+                return i >= 0 && i < arr.length ? arr[i] : null;
+            } catch (NumberFormatException ignored) {}
+        }
+        if (obj instanceof Map<?, ?> map) return map.get(segment);
+
+        // JsonNode: unwrap scalar fields to plain Java values so they compare and
+        // serialize the same way as values read from Map/POJO variables.
+        if (obj instanceof JsonNode jn) {
+            return unwrapJson(jn.get(segment));
+        }
+
+        // Fallback for POJOs: try bean getters first, then a declared field
+        // (climbing the class hierarchy). Read-only — writes reject POJO parents.
+        String cap = Character.toUpperCase(segment.charAt(0)) + segment.substring(1);
+        try {
+            return obj.getClass().getMethod("get" + cap).invoke(obj);
+        } catch (Exception ignored) {}
+        try {
+            return obj.getClass().getMethod("is"  + cap).invoke(obj);
+        } catch (Exception ignored) {}
+        try {
+            java.lang.reflect.Field f = findField(obj.getClass(), segment);
+            if (f != null) { f.setAccessible(true); return f.get(obj); }
+        } catch (Exception ignored) {}
+        LOGGER.warn("varutil: cannot resolve '{}' on {}", segment, obj.getClass().getName());
+        return null;
+    }
+
+    /** Looks up a declared field by name, walking up the class hierarchy. */
+    private static java.lang.reflect.Field findField(Class<?> c, String name) {
+        while (c != null && c != Object.class) {
+            try { return c.getDeclaredField(name); }
+            catch (NoSuchFieldException e) { c = c.getSuperclass(); }
+        }
+        return null;
+    }
+
+    // -------------------------------------------------------------------------
+    // Snapshot persistence
+    // -------------------------------------------------------------------------
+
+    /**
+     * Loads the previous-values snapshot: reads the variable at {@code path}
+     * (persisted as a JSON string by {@link #saveSnapshot}) and parses it back
+     * into a path → value-node map. Returns an empty map when there is no
+     * snapshot yet (first call) or it is unreadable.
+     */
+    private Map<String, JsonNode> loadSnapshot(VariableScope scope, String path) {
+        Object raw = readVariableFromPath(scope, path);
+        if (raw == null) return new HashMap<>();
+        try {
+            String json = raw instanceof String s ? s : MAPPER.writeValueAsString(raw);
+            Map<String, Object> flat = MAPPER.readValue(json,
+                    MAPPER.getTypeFactory().constructMapType(HashMap.class, String.class, Object.class));
+            Map<String, JsonNode> result = new HashMap<>();
+            flat.forEach((k, v) -> result.put(k, toJson(v)));
+            return result;
+        } catch (Exception e) {
+            LOGGER.warn("varutil: could not load snapshot at '{}': {}", path, e.getMessage());
+            return new HashMap<>();
+        }
+    }
+
+    /** Persists the snapshot map as a JSON string variable at {@code path}. */
+    private void saveSnapshot(VariableScope scope, String path, Map<String, JsonNode> snapshot) {
+        try {
+            writeVariableToPath(scope, path, MAPPER.writeValueAsString(snapshot));
+        } catch (Exception e) {
+            LOGGER.error("varutil: could not save snapshot at '{}'", path, e);
+        }
+    }
+
+    // -------------------------------------------------------------------------
+    // Helpers
+    // -------------------------------------------------------------------------
+
+    /** True for null, an empty String, or an empty List/Map/array/JSON container. */
+    private static boolean isEmptyValue(Object value) {
+        if (value == null) return true;
+        if (value instanceof String s) return s.isEmpty();
+        if (value instanceof java.util.Collection<?> c) return c.isEmpty();
+        if (value instanceof Map<?, ?> m) return m.isEmpty();
+        if (value instanceof Object[] arr) return arr.length == 0;
+        if (value instanceof JsonNode jn) {
+            if (jn.isNull() || jn.isMissingNode()) return true;
+            if (jn.isTextual()) return jn.asText().isEmpty();
+            if (jn.isContainerNode()) return jn.size() == 0;
+            return false;
+        }
+        return false;
+    }
+
+    /** JSON-normalized equality, so numeric types and JsonNode wrappers compare naturally. */
+    private static boolean jsonEquals(Object a, Object b) {
+        return normalize(toJson(a)).equals(normalize(toJson(b)));
+    }
+
+    /** Containment test for {@link #contains}: substring or element equality. */
+    private static boolean containsValue(Object container, Object value) {
+        if (container instanceof String s) return value != null && s.contains(value.toString());
+        if (container instanceof java.util.Collection<?> c) {
+            for (Object element : c) if (jsonEquals(element, value)) return true;
+            return false;
+        }
+        if (container instanceof Object[] arr) {
+            for (Object element : arr) if (jsonEquals(element, value)) return true;
+            return false;
+        }
+        if (container instanceof JsonNode jn && jn.isArray()) {
+            for (JsonNode element : jn) if (jsonEquals(element, value)) return true;
+            return false;
+        }
+        return false;
+    }
+
+    /** Numeric comparison via BigDecimal; null when either side is not a number. */
+    private static Integer compareNumeric(Object a, Object b) {
+        java.math.BigDecimal numA = toNumber(a);
+        java.math.BigDecimal numB = toNumber(b);
+        return numA == null || numB == null ? null : numA.compareTo(numB);
+    }
+
+    /** Converts a Number or numeric JsonNode to BigDecimal, anything else to null. */
+    private static java.math.BigDecimal toNumber(Object value) {
+        if (value instanceof JsonNode jn) return jn.isNumber() ? jn.decimalValue() : null;
+        if (value instanceof Number n) return new java.math.BigDecimal(n.toString());
+        return null;
+    }
+
+    /** Appends one change entry to the result array. */
+    private static void addChange(ArrayNode changes, String path, JsonNode oldValue, JsonNode newValue) {
+        ObjectNode change = MAPPER.createObjectNode();
+        change.put("path", path);
+        change.set("oldValue", oldValue);
+        change.set("newValue", newValue);
+        changes.add(change);
+    }
+
+    /** Unwraps a scalar JsonNode to its plain Java value; containers pass through. */
+    private static Object unwrapJson(JsonNode node) {
+        if (node == null || node.isNull()) return null;
+        if (node.isTextual()) return node.asText();
+        if (node.isBoolean()) return node.asBoolean();
+        if (node.isLong())    return node.asLong();
+        if (node.isInt())     return node.asInt();
+        if (node.isDouble())  return node.asDouble();
+        return node;
+    }
+
+    /** Wraps any Java value into a JsonNode (null-safe). */
+    private static JsonNode toJson(Object value) {
+        if (value == null) return MAPPER.nullNode();
+        if (value instanceof JsonNode jn) return jn;
+        return MAPPER.valueToTree(value);
+    }
+
+    /**
+     * Serializes and re-parses a node so its value types match what
+     * {@link #loadSnapshot} produces when reading the persisted snapshot back
+     * (e.g. a Long 5 read from a variable and an Integer 5 parsed from the
+     * snapshot JSON both become the same numeric node). Without this, unchanged
+     * numeric values would be reported as changes on every call.
+     */
+    private static JsonNode normalize(JsonNode node) {
+        try {
+            return MAPPER.readTree(MAPPER.writeValueAsString(node));
+        } catch (Exception e) {
+            return node;
+        }
+    }
+}
diff --git a/customer-work/src/main/java/com/customer/work/service/VarUtils.java b/customer-work/src/main/java/com/customer/work/service/VarUtils.java
deleted file mode 100644
index 182bce8..0000000
--- a/customer-work/src/main/java/com/customer/work/service/VarUtils.java
+++ /dev/null
@@ -1,420 +0,0 @@
-package com.customer.work.service;
-
-import com.fasterxml.jackson.databind.JsonNode;
-import com.fasterxml.jackson.databind.ObjectMapper;
-import com.fasterxml.jackson.databind.SerializationFeature;
-import com.fasterxml.jackson.databind.node.ArrayNode;
-import com.fasterxml.jackson.databind.node.ObjectNode;
-import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
-import org.flowable.cmmn.api.CmmnRuntimeService;
-import org.flowable.cmmn.api.runtime.CaseInstance;
-import org.flowable.cmmn.api.runtime.PlanItemInstance;
-import org.flowable.cmmn.engine.impl.persistence.entity.CaseInstanceEntity;
-import org.flowable.engine.RuntimeService;
-import org.flowable.engine.delegate.DelegateExecution;
-import org.flowable.engine.impl.persistence.entity.ExecutionEntity;
-import org.flowable.engine.runtime.Execution;
-import org.flowable.engine.runtime.ProcessInstance;
-import org.flowable.variable.api.delegate.VariableScope;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.stereotype.Component;
-
-import java.util.Arrays;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-/**
- * General-purpose Flowable variable utility bean for tracking variable changes.
- * Usable in BPMN process and CMMN case backend expressions:
- *   ${varUtils.trackVars('root.snapshot', 'order.customer.name,order.total,status')}
- *   ${varUtils.trackVars(execution, 'root.snapshot', 'status')}          — BPMN, explicit scope
- *   ${varUtils.trackVars(planItemInstance, 'root.snapshot', 'status')}   — CMMN, explicit scope
- * Variable paths use dot notation; a leading "root." prefix addresses the root
- * instance of a nested case/process hierarchy.
- */
-@Component("varUtils")
-public class VarUtils {
-
-    private static final Logger LOGGER = LoggerFactory.getLogger(VarUtils.class);
-
-    private static final ObjectMapper MAPPER;
-    static {
-        MAPPER = new ObjectMapper();
-        MAPPER.registerModule(new JavaTimeModule());
-        MAPPER.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
-    }
-
-    @Autowired
-    private RuntimeService runtimeService;
-
-    @Autowired
-    private CmmnRuntimeService cmmnRuntimeService;
-
-    // -------------------------------------------------------------------------
-    // Public API — called from Flowable expressions
-    // -------------------------------------------------------------------------
-
-    /**
-     * Checks which of the given comma-separated variable paths changed since the
-     * last call and returns a JSON array describing each change.
-     * Example call:
-     *   ${varUtils.trackVars(self, 'root.snapshot', 'root.status, status')}
-     * Example return value:
-     *   [{"path":"root.status","oldValue":"a","newValue":"b"}, {"path":"status","oldValue":"c","newValue":"d"}]
-     */
-    public ArrayNode trackVars(VariableScope currentScope, String snapshotPath, String variablePathsCsv) {
-
-        // Reject blank parameters early — report "no changes" instead of failing,
-        // so a misconfigured expression cannot break the surrounding process/case.
-        if (snapshotPath == null || snapshotPath.isBlank() || variablePathsCsv == null || variablePathsCsv.isBlank()) {
-            LOGGER.debug("{}.trackVars: empty parameters", getClass().getName());
-            return MAPPER.createArrayNode();
-        }
-
-        // Without a resolvable scope there is nothing to read from or write to.
-        if (currentScope == null) {
-            LOGGER.debug("{}.trackVars: currentScope not found", getClass().getName());
-            return MAPPER.createArrayNode();
-        }
-
-        // Split the CSV into individual variable paths, dropping blanks and whitespace.
-        List<String> paths = Arrays.stream(variablePathsCsv.split(","))
-                .map(String::trim).filter(s -> !s.isEmpty()).toList();
-
-        // Load the previous values (persisted as a JSON string variable at
-        // snapshotPath) to compare the current values against.
-        Map<String, JsonNode> oldSnapshot = loadSnapshot(currentScope, snapshotPath);
-        Map<String, JsonNode> newSnapshot = new HashMap<>();
-        ArrayNode changes = MAPPER.createArrayNode();
-
-        // For every tracked path: read the current value, normalize it so it
-        // compares consistently with the reloaded snapshot, and record a change
-        // entry whenever old != new.
-        for (String path : paths) {
-            JsonNode newValue = normalize(toJson(readVariableFromPath(currentScope, path)));
-            newSnapshot.put(path, newValue);
-
-            JsonNode oldValue = oldSnapshot.getOrDefault(path, MAPPER.nullNode());
-            if (!oldValue.equals(newValue)) {
-                ObjectNode change = MAPPER.createObjectNode();
-                change.put("path", path);
-                change.set("oldValue", oldValue);
-                change.set("newValue", newValue);
-                changes.add(change);
-            }
-        }
-
-        // Persist the current values as the reference snapshot for the next call.
-        saveSnapshot(currentScope, snapshotPath, newSnapshot);
-
-        return changes;
-    }
-
-    // -------------------------------------------------------------------------
-    // Path resolution
-    // -------------------------------------------------------------------------
-
-    /**
-     * Reads a value via a dot-notation path, e.g. "order.customer.name".
-     * The first segment names a Flowable variable; the remaining segments navigate
-     * into that value (maps, lists/arrays by index, JsonNodes, POJOs — see
-     * {@link #getNestedVariable}). Returns null when any segment cannot be resolved.
-     */
-    private Object readVariableFromPath(VariableScope scope, String path) {
-        String[] segments = path.split("\\.", -1);
-        if (segments.length < 1) return null;
-
-        // A leading "root." switches to the root instance of the surrounding
-        // case/process hierarchy before resolving the variable.
-        int startIndex = 0;
-        if ("root".equals(segments[0])) {
-            if (segments.length < 2) return null;
-            startIndex = 1;
-            scope = getRootScope(scope);
-        }
-        if (scope == null) return null;
-
-        // Read the top-level variable, then walk the remaining segments into it.
-        Object currentValue = scope.getVariable(segments[startIndex]);
-        for (int i = startIndex + 1; i < segments.length; i++) {
-            if (currentValue == null) return null;
-            currentValue = getNestedVariable(currentValue, segments[i]);
-        }
-        return currentValue;
-    }
-
-    /**
-     * Writes a value via a dot-notation path (same syntax as
-     * {@link #readVariableFromPath}). A single-segment path sets a plain Flowable
-     * variable; a nested path mutates the container inside the top-level variable
-     * and writes that variable back so the engine persists the change.
-     */
-    private void writeVariableToPath(VariableScope scope, String path, Object value) {
-        String[] segments = path.split("\\.", -1);
-        if (segments.length < 1) return;
-
-        // A leading "root." redirects the write to the root instance of the
-        // surrounding case/process hierarchy.
-        VariableScope targetScope;
-        String[] varSegments;
-        if ("root".equals(segments[0])) {
-            if (segments.length < 2) return;
-            targetScope = getRootScope(scope);
-            varSegments = Arrays.copyOfRange(segments, 1, segments.length);
-        } else {
-            targetScope = scope;
-            varSegments = segments;
-        }
-        if (targetScope == null) return;
-
-        if (varSegments.length == 1) {
-            targetScope.setVariable(varSegments[0], value);
-            return;
-        }
-
-        // Nested path: read the top-level variable, navigate to the parent node,
-        // mutate it in-place, then write the top-level variable back.
-        String topVar = varSegments[0];
-        Object topValue = targetScope.getVariable(topVar);
-
-        Object parent = topValue;
-        for (int i = 1; i < varSegments.length - 1; i++) {
-            if (parent == null) {
-                LOGGER.warn("varUtils.writeVariableToPath: null at '{}' in path '{}'", varSegments[i - 1], path);
-                return;
-            }
-            parent = getNestedVariable(parent, varSegments[i]);
-        }
-
-        if (!setNestedValue(parent, varSegments[varSegments.length - 1], value, path)) return;
-        targetScope.setVariable(topVar, topValue);
-    }
-
-    /**
-     * Sets one key on a mutable container (Map or ObjectNode). Anything else —
-     * including POJOs, which are read-only for this bean — is rejected with a
-     * warning so a bad path never breaks the calling expression.
-     */
-    @SuppressWarnings("unchecked")
-    private boolean setNestedValue(Object parent, String key, Object value, String path) {
-        if (parent instanceof Map map) {
-            map.put(key, value);
-            return true;
-        }
-        if (parent instanceof ObjectNode on) {
-            on.set(key, toJson(value));
-            return true;
-        }
-        LOGGER.warn("varUtils.writeVariableToPath: cannot set '{}' on {} in path '{}'",
-                key, parent == null ? "null" : parent.getClass().getName(), path);
-        return false;
-    }
-
-    // -------------------------------------------------------------------------
-    // Scope resolution
-    // -------------------------------------------------------------------------
-
-    /**
-     * Climbs from the given scope to the root VariableScope of the surrounding
-     * case/process hierarchy, following call-activity parents (BPMN) and
-     * parent/callback links (CMMN) across engine boundaries.
-     */
-    private VariableScope getRootScope(VariableScope scope) {
-        if (scope instanceof DelegateExecution ex) return findBpmnRootScope(ex.getProcessInstanceId());
-        if (scope instanceof PlanItemInstance pii) return findCmmnRootScope(pii.getCaseInstanceId());
-        if (scope instanceof CaseInstance ci) return findCmmnRootScope(ci.getId());
-        return null;
-    }
-
-    /**
-     * Finds the root scope starting from a BPMN process instance:
-     * 1. started by a call activity → recurse into the calling process instance,
-     * 2. started from a CMMN plan item (callback) → continue climbing in the case,
-     * 3. otherwise this process instance is itself the root.
-     * NOTE: the returned object is a detached query result used as VariableScope;
-     * its variable access only works because expression evaluation runs inside an
-     * active Flowable command context.
-     */
-    private VariableScope findBpmnRootScope(String processInstanceId) {
-        if (processInstanceId == null || runtimeService == null) return null;
-        try {
-            Execution piExec = runtimeService.createExecutionQuery()
-                    .executionId(processInstanceId).singleResult();
-            if (piExec != null && piExec.getSuperExecutionId() != null) {
-                Execution superExec = runtimeService.createExecutionQuery()
-                        .executionId(piExec.getSuperExecutionId()).singleResult();
-                if (superExec != null)
-                    return findBpmnRootScope(superExec.getProcessInstanceId());
-            }
-            ProcessInstance pi = runtimeService.createProcessInstanceQuery()
-                    .processInstanceId(processInstanceId).singleResult();
-            if (pi != null && pi.getCallbackType() != null && pi.getCallbackId() != null
-                    && cmmnRuntimeService != null) {
-                PlanItemInstance planItem = cmmnRuntimeService.createPlanItemInstanceQuery()
-                        .planItemInstanceId(pi.getCallbackId()).singleResult();
-                if (planItem != null)
-                    return findCmmnRootScope(planItem.getCaseInstanceId());
-            }
-            return (ExecutionEntity) piExec;  // root: ExecutionEntity implements VariableScope
-        } catch (Exception e) {
-            LOGGER.debug("{}.findBpmnRootScope: BPMN root scope climb failed: {}", getClass().getName(), e.getMessage());
-            return null;
-        }
-    }
-
-    /**
-     * Finds the root scope starting from a CMMN case instance:
-     * 1. sub-case → recurse into the parent case,
-     * 2. started from a BPMN call/task (callback) → continue climbing in the process,
-     * 3. otherwise this case instance is itself the root.
-     * Same detached-query-result caveat as {@link #findBpmnRootScope}.
-     */
-    private VariableScope findCmmnRootScope(String caseInstanceId) {
-        if (caseInstanceId == null || cmmnRuntimeService == null) return null;
-        try {
-            CaseInstance ci = cmmnRuntimeService.createCaseInstanceQuery()
-                    .caseInstanceId(caseInstanceId).singleResult();
-            if (ci == null) return null;
-            if (ci.getParentId() != null)
-                return findCmmnRootScope(ci.getParentId());
-            if (ci.getCallbackType() != null && ci.getCallbackId() != null
-                    && runtimeService != null) {
-                Execution callbackExec = runtimeService.createExecutionQuery()
-                        .executionId(ci.getCallbackId()).singleResult();
-                if (callbackExec != null)
-                    return findBpmnRootScope(callbackExec.getProcessInstanceId());
-            }
-            return (CaseInstanceEntity) ci;  // root: CaseInstanceEntity implements VariableScope
-        } catch (Exception e) {
-            LOGGER.debug("{}.findCmmnRootScope: CMMN root scope climb failed: {}", getClass().getName(), e.getMessage());
-            return null;
-        }
-    }
-
-    /**
-     * Resolves one path segment against a value: list/array index, map key,
-     * JsonNode field (scalars are unwrapped to plain Java values), and finally
-     * POJO access via getX()/isX() getters or a declared field.
-     */
-    private static Object getNestedVariable(Object obj, String segment) {
-        // Empty segments (e.g. from "a..b" or a trailing dot) cannot address anything.
-        if (segment == null || segment.isEmpty()) return null;
-
-        // Lists and arrays are addressed by numeric index, e.g. "items.0.name".
-        if (obj instanceof List<?> list) {
-            try {
-                int i = Integer.parseInt(segment);
-                return i >= 0 && i < list.size() ? list.get(i) : null;
-            } catch (NumberFormatException ignored) {}
-        }
-        if (obj instanceof Object[] arr) {
-            try {
-                int i = Integer.parseInt(segment);
-                return i >= 0 && i < arr.length ? arr[i] : null;
-            } catch (NumberFormatException ignored) {}
-        }
-        if (obj instanceof Map<?, ?> map) return map.get(segment);
-
-        // JsonNode: unwrap scalar fields to plain Java values so they compare and
-        // serialize the same way as values read from Map/POJO variables.
-        if (obj instanceof JsonNode jn) {
-            JsonNode node = jn.get(segment);
-            if (node == null || node.isNull()) return null;
-            if (node.isTextual()) return node.asText();
-            if (node.isBoolean()) return node.asBoolean();
-            if (node.isLong())    return node.asLong();
-            if (node.isInt())     return node.asInt();
-            if (node.isDouble())  return node.asDouble();
-            return node;
-        }
-
-        // Fallback for POJOs: try bean getters first, then a declared field
-        // (climbing the class hierarchy). Read-only — writes reject POJO parents.
-        String cap = Character.toUpperCase(segment.charAt(0)) + segment.substring(1);
-        try {
-            return obj.getClass().getMethod("get" + cap).invoke(obj);
-        } catch (Exception ignored) {}
-        try {
-            return obj.getClass().getMethod("is"  + cap).invoke(obj);
-        } catch (Exception ignored) {}
-        try {
-            java.lang.reflect.Field f = findField(obj.getClass(), segment);
-            if (f != null) { f.setAccessible(true); return f.get(obj); }
-        } catch (Exception ignored) {}
-        LOGGER.warn("varUtils: cannot resolve '{}' on {}", segment, obj.getClass().getName());
-        return null;
-    }
-
-    /** Looks up a declared field by name, walking up the class hierarchy. */
-    private static java.lang.reflect.Field findField(Class<?> c, String name) {
-        while (c != null && c != Object.class) {
-            try { return c.getDeclaredField(name); }
-            catch (NoSuchFieldException e) { c = c.getSuperclass(); }
-        }
-        return null;
-    }
-
-    // -------------------------------------------------------------------------
-    // Snapshot persistence
-    // -------------------------------------------------------------------------
-
-    /**
-     * Loads the previous-values snapshot: reads the variable at {@code path}
-     * (persisted as a JSON string by {@link #saveSnapshot}) and parses it back
-     * into a path → value-node map. Returns an empty map when there is no
-     * snapshot yet (first call) or it is unreadable.
-     */
-    private Map<String, JsonNode> loadSnapshot(VariableScope scope, String path) {
-        Object raw = readVariableFromPath(scope, path);
-        if (raw == null) return new HashMap<>();
-        try {
-            String json = raw instanceof String s ? s : MAPPER.writeValueAsString(raw);
-            Map<String, Object> flat = MAPPER.readValue(json,
-                    MAPPER.getTypeFactory().constructMapType(HashMap.class, String.class, Object.class));
-            Map<String, JsonNode> result = new HashMap<>();
-            flat.forEach((k, v) -> result.put(k, toJson(v)));
-            return result;
-        } catch (Exception e) {
-            LOGGER.warn("varUtils: could not load snapshot at '{}': {}", path, e.getMessage());
-            return new HashMap<>();
-        }
-    }
-
-    /** Persists the snapshot map as a JSON string variable at {@code path}. */
-    private void saveSnapshot(VariableScope scope, String path, Map<String, JsonNode> snapshot) {
-        try {
-            writeVariableToPath(scope, path, MAPPER.writeValueAsString(snapshot));
-        } catch (Exception e) {
-            LOGGER.error("varUtils: could not save snapshot at '{}'", path, e);
-        }
-    }
-
-    // -------------------------------------------------------------------------
-    // Helpers
-    // -------------------------------------------------------------------------
-
-    /** Wraps any Java value into a JsonNode (null-safe). */
-    private static JsonNode toJson(Object value) {
-        if (value == null) return MAPPER.nullNode();
-        if (value instanceof JsonNode jn) return jn;
-        return MAPPER.valueToTree(value);
-    }
-
-    /**
-     * Serializes and re-parses a node so its value types match what
-     * {@link #loadSnapshot} produces when reading the persisted snapshot back
-     * (e.g. a Long 5 read from a variable and an Integer 5 parsed from the
-     * snapshot JSON both become the same numeric node). Without this, unchanged
-     * numeric values would be reported as changes on every call.
-     */
-    private static JsonNode normalize(JsonNode node) {
-        try {
-            return MAPPER.readTree(MAPPER.writeValueAsString(node));
-        } catch (Exception e) {
-            return node;
-        }
-    }
-}
diff --git a/customer-work/src/main/resources/application.properties b/customer-work/src/main/resources/application.properties
index 7d617da..50d2932 100644
--- a/customer-work/src/main/resources/application.properties
+++ b/customer-work/src/main/resources/application.properties
@@ -42,4 +42,3 @@ flowable.security.basic-auth.password=test
 flowable.mail.server.host=localhost
 flowable.mail.server.port=2525
 
-
diff --git a/customer-work/src/test/java/com/customer/work/model/FlowableExcelParser.java b/customer-work/src/test/java/com/customer/work/model/FlowableExcelParser.java
index 38a6ef1..ae9762b 100644
--- a/customer-work/src/test/java/com/customer/work/model/FlowableExcelParser.java
+++ b/customer-work/src/test/java/com/customer/work/model/FlowableExcelParser.java
@@ -1,6 +1,12 @@
 package com.customer.work.model;
 
-import org.apache.poi.ss.usermodel.*;
+import org.apache.poi.ss.usermodel.Cell;
+import org.apache.poi.ss.usermodel.CellType;
+import org.apache.poi.ss.usermodel.DataFormatter;
+import org.apache.poi.ss.usermodel.FormulaEvaluator;
+import org.apache.poi.ss.usermodel.Row;
+import org.apache.poi.ss.usermodel.Sheet;
+import org.apache.poi.ss.usermodel.Workbook;
 import org.apache.poi.xssf.usermodel.XSSFWorkbook;
 import org.springframework.stereotype.Component;
 
diff --git a/customer-work/src/test/java/com/customer/work/model/FlowableModelTestUtils.java b/customer-work/src/test/java/com/customer/work/model/FlowableModelTestUtils.java
index b890b11..e868374 100644
--- a/customer-work/src/test/java/com/customer/work/model/FlowableModelTestUtils.java
+++ b/customer-work/src/test/java/com/customer/work/model/FlowableModelTestUtils.java
@@ -11,11 +11,11 @@ import com.flowable.audit.api.AuditService;
 import com.flowable.audit.api.runtime.AuditInstance;
 import com.flowable.core.spring.security.SecurityUtils;
 import com.flowable.platform.service.task.CompleteFormRepresentation;
-import com.flowable.platform.service.task.PlatformTaskService;
 import com.flowable.serviceregistry.api.runtime.ServiceInvocationResultResponse;
 import com.flowable.serviceregistry.api.runtime.ServiceRegistryRuntimeService;
 import com.github.wnameless.json.flattener.JsonFlattener;
 import com.github.wnameless.json.unflattener.JsonUnflattener;
+import com.flowable.platform.service.task.PlatformTaskService;
 import jakarta.mail.Address;
 import org.assertj.core.api.Assertions;
 import org.flowable.bpmn.model.*;
@@ -39,14 +39,18 @@ import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.http.HttpMethod;
 import org.springframework.http.ResponseEntity;
+import org.springframework.web.client.RestClient;
 import org.springframework.security.authentication.TestingAuthenticationToken;
 import org.springframework.security.core.GrantedAuthority;
 import org.springframework.security.core.context.SecurityContextHolder;
 import org.springframework.stereotype.Component;
 import org.springframework.util.StreamUtils;
-import org.springframework.web.client.RestClient;
 
-import java.io.*;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.UncheckedIOException;
 import java.nio.file.Paths;
 import java.util.*;
 import java.util.stream.Collectors;
diff --git a/customer-work/src/test/java/com/customer/work/model/TestRestServer.java b/customer-work/src/test/java/com/customer/work/model/TestRestServer.java
index ff854fc..931af3e 100644
--- a/customer-work/src/test/java/com/customer/work/model/TestRestServer.java
+++ b/customer-work/src/test/java/com/customer/work/model/TestRestServer.java
@@ -14,6 +14,7 @@ import java.util.ArrayList;
 import java.util.Base64;
 import java.util.LinkedHashMap;
 import java.util.List;
+import java.util.Map;
 import java.util.concurrent.CopyOnWriteArrayList;
 
 /**
diff --git a/customer-work/src/test/java/com/customer/work/model/test/ModelTest.java b/customer-work/src/test/java/com/customer/work/model/test/ModelTest.java
index 52e3fe4..3c3c9ed 100644
--- a/customer-work/src/test/java/com/customer/work/model/test/ModelTest.java
+++ b/customer-work/src/test/java/com/customer/work/model/test/ModelTest.java
@@ -1,11 +1,11 @@
 package com.customer.work.model.test;
 
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.node.ObjectNode;
 import com.customer.work.model.EmailDto;
 import com.customer.work.model.FlowableModelTest;
 import com.customer.work.model.FlowableModelTestUtils;
 import com.customer.work.model.RestRequestDto;
-import com.fasterxml.jackson.databind.JsonNode;
-import com.fasterxml.jackson.databind.node.ObjectNode;
 import com.flowable.serviceregistry.api.runtime.ServiceInvocationResultResponse;
 import org.assertj.core.api.Assertions;
 import org.flowable.cmmn.api.runtime.CaseInstance;
diff --git a/customer-work/src/test/java/com/customer/work/service/VarUtilArrayTrackingTest.java b/customer-work/src/test/java/com/customer/work/service/VarUtilArrayTrackingTest.java
new file mode 100644
index 0000000..e766866
--- /dev/null
+++ b/customer-work/src/test/java/com/customer/work/service/VarUtilArrayTrackingTest.java
@@ -0,0 +1,262 @@
+package com.customer.work.service;
+
+import com.fasterxml.jackson.databind.node.ArrayNode;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Unit test for the array tracking of {@link VarUtil#trackVars}. The
+ * parameterized tests run every scenario against both the local scope
+ * (prefix "") and the root scope (prefix "root."), the latter exercising the
+ * BPMN root-scope climb through the mocked RuntimeService of the base class.
+ */
+class VarUtilArrayTrackingTest extends VarUtilMockScopeTest {
+
+    // -------------------------------------------------------------------------
+    // Combination matrix: every scenario runs for local ("") and root ("root.")
+    // -------------------------------------------------------------------------
+
+    @ParameterizedTest
+    @ValueSource(strings = {"", "root."})
+    void scalarVariable(String prefix) {
+        vars(prefix).put("status", "a");
+        assertPaths(track(prefix + "status"), prefix + "status");
+
+        vars(prefix).put("status", "b");
+        ArrayNode changes = track(prefix + "status");
+        assertPaths(changes, prefix + "status");
+        assertThat(changes.get(0).get("oldValue").asText()).isEqualTo("a");
+        assertThat(changes.get(0).get("newValue").asText()).isEqualTo("b");
+
+        assertThat(track(prefix + "status")).isEmpty();
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = {"", "root."})
+    void nestedObjectField(String prefix) {
+        Map<String, Object> customer = new HashMap<>(Map.of("name", "n1"));
+        vars(prefix).put("order", new HashMap<>(Map.of("customer", customer)));
+        assertPaths(track(prefix + "order.customer.name"), prefix + "order.customer.name");
+
+        customer.put("name", "n2");
+        ArrayNode changes = track(prefix + "order.customer.name");
+        assertPaths(changes, prefix + "order.customer.name");
+        assertThat(changes.get(0).get("oldValue").asText()).isEqualTo("n1");
+        assertThat(changes.get(0).get("newValue").asText()).isEqualTo("n2");
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = {"", "root."})
+    void bareSimpleTypeArray(String prefix) {
+        List<String> status = new ArrayList<>(List.of("a", "b"));
+        vars(prefix).put("status", status);
+        assertPaths(track(prefix + "status"), prefix + "status[0]", prefix + "status[1]");
+
+        status.set(0, "x");
+        ArrayNode changes = track(prefix + "status");
+        assertPaths(changes, prefix + "status[0]");
+        assertThat(changes.get(0).get("oldValue").asText()).isEqualTo("a");
+        assertThat(changes.get(0).get("newValue").asText()).isEqualTo("x");
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = {"", "root."})
+    void explicitSimpleTypeArray(String prefix) {
+        List<String> status = new ArrayList<>(List.of("a", "b"));
+        vars(prefix).put("status", status);
+        assertPaths(track(prefix + "status[]"), prefix + "status[0]", prefix + "status[1]");
+
+        status.set(1, "x");
+        assertPaths(track(prefix + "status[]"), prefix + "status[1]");
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = {"", "root."})
+    void bareObjectArray(String prefix) {
+        List<Map<String, Object>> orders = new ArrayList<>(List.of(
+                new HashMap<>(Map.of("name", "n1")), new HashMap<>(Map.of("name", "n2"))));
+        vars(prefix).put("orders", orders);
+        assertPaths(track(prefix + "orders"), prefix + "orders[0]", prefix + "orders[1]");
+
+        orders.get(1).put("name", "changed");
+        ArrayNode changes = track(prefix + "orders");
+        assertPaths(changes, prefix + "orders[1]");
+        assertThat(changes.get(0).get("oldValue").get("name").asText()).isEqualTo("n2");
+        assertThat(changes.get(0).get("newValue").get("name").asText()).isEqualTo("changed");
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = {"", "root."})
+    void objectArrayField(String prefix) {
+        ArrayNode orders = MAPPER.createArrayNode();
+        orders.addObject().put("name", "n1");
+        orders.addObject().put("name", "n2");
+        vars(prefix).put("orders", orders);
+        assertPaths(track(prefix + "orders[].name"),
+                prefix + "orders[0].name", prefix + "orders[1].name");
+
+        ((ObjectNode) orders.get(0)).put("name", "changed");
+        ArrayNode changes = track(prefix + "orders[].name");
+        assertPaths(changes, prefix + "orders[0].name");
+        assertThat(changes.get(0).get("oldValue").asText()).isEqualTo("n1");
+        assertThat(changes.get(0).get("newValue").asText()).isEqualTo("changed");
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = {"", "root."})
+    void bareArrayInNestedObject(String prefix) {
+        List<Map<String, Object>> items = new ArrayList<>(List.of(item(1), item(2)));
+        vars(prefix).put("order", new HashMap<>(Map.of("items", items)));
+        assertPaths(track(prefix + "order.items"),
+                prefix + "order.items[0]", prefix + "order.items[1]");
+
+        items.get(0).put("qty", 9);
+        assertPaths(track(prefix + "order.items"), prefix + "order.items[0]");
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = {"", "root."})
+    void explicitArrayInNestedObject(String prefix) {
+        List<Map<String, Object>> items = new ArrayList<>(List.of(item(1), item(2)));
+        vars(prefix).put("order", new HashMap<>(Map.of("items", items)));
+        assertPaths(track(prefix + "order.items[].qty"),
+                prefix + "order.items[0].qty", prefix + "order.items[1].qty");
+
+        items.get(1).put("qty", 5);
+        ArrayNode changes = track(prefix + "order.items[].qty");
+        assertPaths(changes, prefix + "order.items[1].qty");
+        assertThat(changes.get(0).get("oldValue").asInt()).isEqualTo(2);
+        assertThat(changes.get(0).get("newValue").asInt()).isEqualTo(5);
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = {"", "root."})
+    void nestedArraysExplicit(String prefix) {
+        List<Map<String, Object>> orders = nestedOrders();
+        vars(prefix).put("orders", orders);
+        assertPaths(track(prefix + "orders[].items[].qty"),
+                prefix + "orders[0].items[0].qty", prefix + "orders[0].items[1].qty",
+                prefix + "orders[1].items[0].qty");
+
+        item(orders, 1, 0).put("qty", 99);
+        ArrayNode changes = track(prefix + "orders[].items[].qty");
+        assertPaths(changes, prefix + "orders[1].items[0].qty");
+        assertThat(changes.get(0).get("oldValue").asInt()).isEqualTo(3);
+        assertThat(changes.get(0).get("newValue").asInt()).isEqualTo(99);
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = {"", "root."})
+    void bareTailAfterExplicitArray(String prefix) {
+        List<Map<String, Object>> orders = nestedOrders();
+        vars(prefix).put("orders", orders);
+        assertPaths(track(prefix + "orders[].items"),
+                prefix + "orders[0].items[0]", prefix + "orders[0].items[1]",
+                prefix + "orders[1].items[0]");
+
+        item(orders, 0, 1).put("qty", 7);
+        assertPaths(track(prefix + "orders[].items"), prefix + "orders[0].items[1]");
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = {"", "root."})
+    void bareArrayOfArrays(String prefix) {
+        List<List<Integer>> matrix = new ArrayList<>(List.of(
+                new ArrayList<>(List.of(1, 2)), new ArrayList<>(List.of(3))));
+        vars(prefix).put("matrix", matrix);
+        assertPaths(track(prefix + "matrix"),
+                prefix + "matrix[0][0]", prefix + "matrix[0][1]", prefix + "matrix[1][0]");
+
+        matrix.get(0).set(1, 20);
+        ArrayNode changes = track(prefix + "matrix");
+        assertPaths(changes, prefix + "matrix[0][1]");
+        assertThat(changes.get(0).get("oldValue").asInt()).isEqualTo(2);
+        assertThat(changes.get(0).get("newValue").asInt()).isEqualTo(20);
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = {"", "root."})
+    void explicitArrayOfArrays(String prefix) {
+        List<List<Integer>> matrix = new ArrayList<>(List.of(
+                new ArrayList<>(List.of(1, 2)), new ArrayList<>(List.of(3))));
+        vars(prefix).put("matrix", matrix);
+        assertPaths(track(prefix + "matrix[][]"),
+                prefix + "matrix[0][0]", prefix + "matrix[0][1]", prefix + "matrix[1][0]");
+
+        matrix.get(1).set(0, 30);
+        assertPaths(track(prefix + "matrix[][]"), prefix + "matrix[1][0]");
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = {"", "root."})
+    void growAndShrinkBareArray(String prefix) {
+        List<String> status = new ArrayList<>(List.of("a"));
+        vars(prefix).put("status", status);
+        track(prefix + "status");
+
+        status.add("b");
+        ArrayNode grown = track(prefix + "status");
+        assertPaths(grown, prefix + "status[1]");
+        assertThat(grown.get(0).get("oldValue").isNull()).isTrue();
+        assertThat(grown.get(0).get("newValue").asText()).isEqualTo("b");
+
+        status.remove(1);
+        ArrayNode shrunk = track(prefix + "status");
+        assertPaths(shrunk, prefix + "status[1]");
+        assertThat(shrunk.get(0).get("oldValue").asText()).isEqualTo("b");
+        assertThat(shrunk.get(0).get("newValue").isNull()).isTrue();
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = {"", "root."})
+    void shapeChangeBetweenScalarAndArray(String prefix) {
+        vars(prefix).put("status", "x");
+        track(prefix + "status");
+
+        // scalar -> array: the element appears, the scalar entry is retired
+        vars(prefix).put("status", new ArrayList<>(List.of("a")));
+        assertPaths(track(prefix + "status"), prefix + "status[0]", prefix + "status");
+
+        // array -> scalar: the scalar reappears, the element entry is retired
+        vars(prefix).put("status", "y");
+        assertPaths(track(prefix + "status"), prefix + "status", prefix + "status[0]");
+    }
+
+    // -------------------------------------------------------------------------
+    // Local-only edge cases
+    // -------------------------------------------------------------------------
+
+    @Test
+    void nonArrayValueWithExplicitBracketsExpandsToNothing() {
+        localVars.put("status", "notAnArray");
+        assertThat(track("status[]")).isEmpty();
+    }
+
+    @Test
+    void emptyArrayTracksNothing() {
+        localVars.put("status", new ArrayList<>());
+        assertThat(track("status")).isEmpty();
+    }
+
+    // -------------------------------------------------------------------------
+    // Helpers
+    // -------------------------------------------------------------------------
+
+    private ArrayNode track(String csv) {
+        return varUtil.trackVars(scope, "snap", csv);
+    }
+
+    private static void assertPaths(ArrayNode changes, String... paths) {
+        assertThat(changes).extracting(c -> c.get("path").asText())
+                .containsExactlyInAnyOrder(paths);
+    }
+}
diff --git a/customer-work/src/test/java/com/customer/work/service/VarUtilExpressionFunctionsTest.java b/customer-work/src/test/java/com/customer/work/service/VarUtilExpressionFunctionsTest.java
new file mode 100644
index 0000000..791b259
--- /dev/null
+++ b/customer-work/src/test/java/com/customer/work/service/VarUtilExpressionFunctionsTest.java
@@ -0,0 +1,154 @@
+package com.customer.work.service;
+
+import com.fasterxml.jackson.databind.node.ArrayNode;
+import org.junit.jupiter.api.Test;
+
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Unit test for the null-safe var:-style expression functions of
+ * {@link VarUtil} (get, exists, isEmpty, equals, contains, comparisons,
+ * base64), focused on null safety in nested arrays.
+ */
+class VarUtilExpressionFunctionsTest extends VarUtilMockScopeTest {
+
+    @Test
+    void getIsNullSafe() {
+        assertThat(varUtil.get(scope, "missing")).isNull();
+        assertThat(varUtil.get(scope, "missing.customer.name")).isNull();
+
+        localVars.put("orders", nestedOrders());
+        assertThat(varUtil.get(scope, "orders[5].items[0].qty")).isNull();  // index out of bounds
+        assertThat(varUtil.get(scope, "orders[0].nope.qty")).isNull();      // missing field
+        assertThat(varUtil.get(scope, "orders[0].items[7]")).isNull();      // nested index out of bounds
+        assertThat(varUtil.get(null, "orders")).isNull();                   // no scope
+        assertThat(varUtil.get(scope, null)).isNull();                      // no path
+    }
+
+    @Test
+    void getReadsNestedArrays() {
+        localVars.put("orders", nestedOrders());
+        assertThat(varUtil.get(scope, "orders[1].items[0].qty")).isEqualTo(3);
+
+        rootVars.put("orders", nestedOrders());
+        assertThat(varUtil.get(scope, "root.orders[0].items[1].qty")).isEqualTo(2);
+    }
+
+    @Test
+    void getProjectsArraysWithBrackets() {
+        List<Map<String, Object>> orders = new ArrayList<>(List.of(
+                new HashMap<>(Map.of("name", "n1")), new HashMap<>(Map.of("name", "n2"))));
+        localVars.put("orders", orders);
+        assertThat(varUtil.get(scope, "orders[].name")).isEqualTo(List.of("n1", "n2"));
+
+        localVars.put("nested", nestedOrders());
+        assertThat(varUtil.get(scope, "nested[].items[].qty")).isEqualTo(List.of(1, 2, 3));
+
+        // bare array names are NOT projected — the array itself is returned
+        assertThat(varUtil.get(scope, "orders")).isSameAs(orders);
+
+        // missing fields yield null entries
+        orders.get(1).remove("name");
+        assertThat(varUtil.get(scope, "orders[].name")).isEqualTo(Arrays.asList("n1", null));
+    }
+
+    @Test
+    void getOrDefaultFallsBack() {
+        assertThat(varUtil.getOrDefault(scope, "missing", "dflt")).isEqualTo("dflt");
+        localVars.put("orders", nestedOrders());
+        assertThat(varUtil.getOrDefault(scope, "orders[5].items[0].qty", 0)).isEqualTo(0);
+        assertThat(varUtil.getOrDefault(scope, "orders[0].items[0].qty", 0)).isEqualTo(1);
+    }
+
+    @Test
+    void existsChecksResolvability() {
+        localVars.put("orders", nestedOrders());
+        assertThat(varUtil.exists(scope, "orders[0].items[1].qty")).isTrue();
+        assertThat(varUtil.exists(scope, "orders[0].items[9].qty")).isFalse();
+        assertThat(varUtil.exists(scope, "missing")).isFalse();
+    }
+
+    @Test
+    void isEmptyHandlesAllContainerTypes() {
+        assertThat(varUtil.isEmpty(scope, "missing")).isTrue();
+        localVars.put("blank", "");
+        localVars.put("text", "x");
+        localVars.put("emptyList", new ArrayList<>());
+        localVars.put("emptyJson", MAPPER.createArrayNode());
+        assertThat(varUtil.isEmpty(scope, "blank")).isTrue();
+        assertThat(varUtil.isEmpty(scope, "text")).isFalse();
+        assertThat(varUtil.isEmpty(scope, "emptyList")).isTrue();
+        assertThat(varUtil.isEmpty(scope, "emptyJson")).isTrue();
+        assertThat(varUtil.isNotEmpty(scope, "text")).isTrue();
+
+        // a projection over a missing array is an empty list
+        assertThat(varUtil.isEmpty(scope, "missing[].name")).isTrue();
+    }
+
+    @Test
+    void equalsNormalizesTypes() {
+        localVars.put("orders", nestedOrders());
+        assertThat(varUtil.equals(scope, "orders[0].items[1].qty", 2)).isTrue();
+        assertThat(varUtil.equals(scope, "orders[0].items[1].qty", 2L)).isTrue();   // Long vs Integer
+        assertThat(varUtil.equals(scope, "orders[0].items[1].qty", 3)).isFalse();
+        assertThat(varUtil.equals(scope, "orders[9].items[0].qty", null)).isTrue(); // unresolvable equals null
+        assertThat(varUtil.notEquals(scope, "orders[0].items[1].qty", 3)).isTrue();
+
+        ArrayNode json = MAPPER.createArrayNode();
+        json.addObject().put("name", "n1");
+        localVars.put("json", json);
+        assertThat(varUtil.equals(scope, "json[0].name", "n1")).isTrue();           // JsonNode vs String
+    }
+
+    @Test
+    void containsWorksOnStringsArraysAndProjections() {
+        localVars.put("greeting", "hello world");
+        assertThat(varUtil.contains(scope, "greeting", "hello", "world")).isTrue();
+        assertThat(varUtil.contains(scope, "greeting", "hello", "mars")).isFalse();
+        assertThat(varUtil.containsAny(scope, "greeting", "mars", "world")).isTrue();
+        assertThat(varUtil.containsAny(scope, "greeting", "mars", "venus")).isFalse();
+
+        localVars.put("tags", new ArrayList<>(List.of("a", "b")));
+        assertThat(varUtil.contains(scope, "tags", "a", "b")).isTrue();
+        assertThat(varUtil.contains(scope, "tags", "a", "c")).isFalse();
+
+        localVars.put("nums", MAPPER.createArrayNode().add(1).add(2));
+        assertThat(varUtil.contains(scope, "nums", 1, 2)).isTrue();                 // JSON array vs Integer
+
+        localVars.put("orders", nestedOrders());
+        assertThat(varUtil.contains(scope, "orders[].items[].qty", 3)).isTrue();    // projection
+        assertThat(varUtil.contains(scope, "orders[].items[].qty", 4)).isFalse();
+
+        assertThat(varUtil.contains(scope, "missing", "x")).isFalse();              // null-safe
+    }
+
+    @Test
+    void numericComparisonsAreNullSafe() {
+        localVars.put("orders", nestedOrders());
+        assertThat(varUtil.lowerThan(scope, "orders[0].items[0].qty", 2)).isTrue();          // 1 < 2
+        assertThat(varUtil.lowerThan(scope, "orders[0].items[0].qty", 1)).isFalse();
+        assertThat(varUtil.lowerThanOrEquals(scope, "orders[0].items[0].qty", 1)).isTrue();
+        assertThat(varUtil.greaterThan(scope, "orders[1].items[0].qty", 2)).isTrue();        // 3 > 2
+        assertThat(varUtil.greaterThanOrEquals(scope, "orders[1].items[0].qty", 3)).isTrue();
+
+        assertThat(varUtil.greaterThan(scope, "orders[9].items[0].qty", 2)).isFalse();       // null -> false
+        localVars.put("text", "abc");
+        assertThat(varUtil.lowerThan(scope, "text", 2)).isFalse();                           // non-numeric -> false
+    }
+
+    @Test
+    void base64EncodesStringsAndBytes() {
+        localVars.put("text", "hello");
+        assertThat(varUtil.base64(scope, "text")).isEqualTo("aGVsbG8=");
+        localVars.put("bytes", "hello".getBytes(StandardCharsets.UTF_8));
+        assertThat(varUtil.base64(scope, "bytes")).isEqualTo("aGVsbG8=");
+        assertThat(varUtil.base64(scope, "missing")).isNull();
+    }
+}
diff --git a/customer-work/src/test/java/com/customer/work/service/VarUtilMockScopeTest.java b/customer-work/src/test/java/com/customer/work/service/VarUtilMockScopeTest.java
new file mode 100644
index 0000000..449a6e3
--- /dev/null
+++ b/customer-work/src/test/java/com/customer/work/service/VarUtilMockScopeTest.java
@@ -0,0 +1,81 @@
+package com.customer.work.service;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.flowable.engine.RuntimeService;
+import org.flowable.engine.delegate.DelegateExecution;
+import org.flowable.engine.impl.persistence.entity.ExecutionEntity;
+import org.junit.jupiter.api.BeforeEach;
+import org.springframework.test.util.ReflectionTestUtils;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+/**
+ * Shared scaffolding for varutil unit tests: a map-backed local scope
+ * (DelegateExecution) plus a mocked BPMN root scope resolved through a mocked
+ * RuntimeService, so "root." paths work without an engine.
+ */
+abstract class VarUtilMockScopeTest {
+
+    protected static final ObjectMapper MAPPER = new ObjectMapper();
+
+    protected final VarUtil varUtil = new VarUtil();
+    protected final Map<String, Object> localVars = new HashMap<>();
+    protected final Map<String, Object> rootVars = new HashMap<>();
+    protected DelegateExecution scope;
+
+    @BeforeEach
+    void setUpScopes() {
+        // Local scope: a DelegateExecution whose variables live in localVars.
+        scope = mock(DelegateExecution.class);
+        when(scope.getVariable(anyString())).thenAnswer(inv -> localVars.get(inv.<String>getArgument(0)));
+        doAnswer(inv -> localVars.put(inv.getArgument(0), inv.getArgument(1)))
+                .when(scope).setVariable(anyString(), any());
+        when(scope.getProcessInstanceId()).thenReturn("pi1");
+
+        // Root scope: the process-instance execution that findBpmnRootScope
+        // resolves for "root." paths, backed by rootVars.
+        ExecutionEntity rootExec = mock(ExecutionEntity.class);
+        when(rootExec.getVariable(anyString())).thenAnswer(inv -> rootVars.get(inv.<String>getArgument(0)));
+        doAnswer(inv -> rootVars.put(inv.getArgument(0), inv.getArgument(1)))
+                .when(rootExec).setVariable(anyString(), any());
+
+        RuntimeService runtimeService = mock(RuntimeService.class, RETURNS_DEEP_STUBS);
+        when(runtimeService.createExecutionQuery().executionId("pi1").singleResult()).thenReturn(rootExec);
+        when(runtimeService.createProcessInstanceQuery().processInstanceId("pi1").singleResult()).thenReturn(null);
+        ReflectionTestUtils.setField(varUtil, "runtimeService", runtimeService);
+    }
+
+    /** Variable map for a path prefix: "" -> local scope, "root." -> root scope. */
+    protected Map<String, Object> vars(String prefix) {
+        return prefix.isEmpty() ? localVars : rootVars;
+    }
+
+    /** [{items:[{qty:1},{qty:2}]}, {items:[{qty:3}]}] as mutable lists/maps. */
+    protected static List<Map<String, Object>> nestedOrders() {
+        List<Map<String, Object>> orders = new ArrayList<>();
+        orders.add(new HashMap<>(Map.of("items", new ArrayList<>(List.of(item(1), item(2))))));
+        orders.add(new HashMap<>(Map.of("items", new ArrayList<>(List.of(item(3))))));
+        return orders;
+    }
+
+    protected static Map<String, Object> item(int qty) {
+        Map<String, Object> m = new HashMap<>();
+        m.put("qty", qty);
+        return m;
+    }
+
+    @SuppressWarnings("unchecked")
+    protected static Map<String, Object> item(List<Map<String, Object>> orders, int order, int item) {
+        return ((List<Map<String, Object>>) orders.get(order).get("items")).get(item);
+    }
+}
diff --git a/customer-work/src/test/java/com/customer/work/service/VarUtilTest.java b/customer-work/src/test/java/com/customer/work/service/VarUtilTest.java
new file mode 100644
index 0000000..3ac95fe
--- /dev/null
+++ b/customer-work/src/test/java/com/customer/work/service/VarUtilTest.java
@@ -0,0 +1,327 @@
+package com.customer.work.service;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ArrayNode;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import org.flowable.engine.RuntimeService;
+import org.flowable.engine.delegate.DelegateExecution;
+import org.flowable.engine.impl.persistence.entity.ExecutionEntity;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+import org.springframework.test.util.ReflectionTestUtils;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+/**
+ * Unit test for the array tracking of {@link VarUtil#trackVars}, using
+ * map-backed mock scopes so no engine is required. The parameterized tests run
+ * every scenario against both the local scope (prefix "") and the root scope
+ * (prefix "root."), the latter exercising the BPMN root-scope climb through a
+ * mocked RuntimeService.
+ */
+class VarUtilTest {
+
+    private static final ObjectMapper MAPPER = new ObjectMapper();
+
+    private final VarUtil varUtil = new VarUtil();
+    private final Map<String, Object> localVars = new HashMap<>();
+    private final Map<String, Object> rootVars = new HashMap<>();
+    private DelegateExecution scope;
+
+    @BeforeEach
+    void setUp() {
+        // Local scope: a DelegateExecution whose variables live in localVars.
+        scope = mock(DelegateExecution.class);
+        when(scope.getVariable(anyString())).thenAnswer(inv -> localVars.get(inv.<String>getArgument(0)));
+        doAnswer(inv -> localVars.put(inv.getArgument(0), inv.getArgument(1)))
+                .when(scope).setVariable(anyString(), any());
+        when(scope.getProcessInstanceId()).thenReturn("pi1");
+
+        // Root scope: the process-instance execution that findBpmnRootScope
+        // resolves for "root." paths, backed by rootVars.
+        ExecutionEntity rootExec = mock(ExecutionEntity.class);
+        when(rootExec.getVariable(anyString())).thenAnswer(inv -> rootVars.get(inv.<String>getArgument(0)));
+        doAnswer(inv -> rootVars.put(inv.getArgument(0), inv.getArgument(1)))
+                .when(rootExec).setVariable(anyString(), any());
+
+        RuntimeService runtimeService = mock(RuntimeService.class, RETURNS_DEEP_STUBS);
+        when(runtimeService.createExecutionQuery().executionId("pi1").singleResult()).thenReturn(rootExec);
+        when(runtimeService.createProcessInstanceQuery().processInstanceId("pi1").singleResult()).thenReturn(null);
+        ReflectionTestUtils.setField(varUtil, "runtimeService", runtimeService);
+    }
+
+    // -------------------------------------------------------------------------
+    // Combination matrix: every scenario runs for local ("") and root ("root.")
+    // -------------------------------------------------------------------------
+
+    @ParameterizedTest
+    @ValueSource(strings = {"", "root."})
+    void scalarVariable(String prefix) {
+        vars(prefix).put("status", "a");
+        assertPaths(track(prefix + "status"), prefix + "status");
+
+        vars(prefix).put("status", "b");
+        ArrayNode changes = track(prefix + "status");
+        assertPaths(changes, prefix + "status");
+        assertThat(changes.get(0).get("oldValue").asText()).isEqualTo("a");
+        assertThat(changes.get(0).get("newValue").asText()).isEqualTo("b");
+
+        assertThat(track(prefix + "status")).isEmpty();
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = {"", "root."})
+    void nestedObjectField(String prefix) {
+        Map<String, Object> customer = new HashMap<>(Map.of("name", "n1"));
+        vars(prefix).put("order", new HashMap<>(Map.of("customer", customer)));
+        assertPaths(track(prefix + "order.customer.name"), prefix + "order.customer.name");
+
+        customer.put("name", "n2");
+        ArrayNode changes = track(prefix + "order.customer.name");
+        assertPaths(changes, prefix + "order.customer.name");
+        assertThat(changes.get(0).get("oldValue").asText()).isEqualTo("n1");
+        assertThat(changes.get(0).get("newValue").asText()).isEqualTo("n2");
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = {"", "root."})
+    void bareSimpleTypeArray(String prefix) {
+        List<String> status = new ArrayList<>(List.of("a", "b"));
+        vars(prefix).put("status", status);
+        assertPaths(track(prefix + "status"), prefix + "status[0]", prefix + "status[1]");
+
+        status.set(0, "x");
+        ArrayNode changes = track(prefix + "status");
+        assertPaths(changes, prefix + "status[0]");
+        assertThat(changes.get(0).get("oldValue").asText()).isEqualTo("a");
+        assertThat(changes.get(0).get("newValue").asText()).isEqualTo("x");
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = {"", "root."})
+    void explicitSimpleTypeArray(String prefix) {
+        List<String> status = new ArrayList<>(List.of("a", "b"));
+        vars(prefix).put("status", status);
+        assertPaths(track(prefix + "status[]"), prefix + "status[0]", prefix + "status[1]");
+
+        status.set(1, "x");
+        assertPaths(track(prefix + "status[]"), prefix + "status[1]");
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = {"", "root."})
+    void bareObjectArray(String prefix) {
+        List<Map<String, Object>> orders = new ArrayList<>(List.of(
+                new HashMap<>(Map.of("name", "n1")), new HashMap<>(Map.of("name", "n2"))));
+        vars(prefix).put("orders", orders);
+        assertPaths(track(prefix + "orders"), prefix + "orders[0]", prefix + "orders[1]");
+
+        orders.get(1).put("name", "changed");
+        ArrayNode changes = track(prefix + "orders");
+        assertPaths(changes, prefix + "orders[1]");
+        assertThat(changes.get(0).get("oldValue").get("name").asText()).isEqualTo("n2");
+        assertThat(changes.get(0).get("newValue").get("name").asText()).isEqualTo("changed");
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = {"", "root."})
+    void objectArrayField(String prefix) {
+        ArrayNode orders = MAPPER.createArrayNode();
+        orders.addObject().put("name", "n1");
+        orders.addObject().put("name", "n2");
+        vars(prefix).put("orders", orders);
+        assertPaths(track(prefix + "orders[].name"),
+                prefix + "orders[0].name", prefix + "orders[1].name");
+
+        ((ObjectNode) orders.get(0)).put("name", "changed");
+        ArrayNode changes = track(prefix + "orders[].name");
+        assertPaths(changes, prefix + "orders[0].name");
+        assertThat(changes.get(0).get("oldValue").asText()).isEqualTo("n1");
+        assertThat(changes.get(0).get("newValue").asText()).isEqualTo("changed");
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = {"", "root."})
+    void bareArrayInNestedObject(String prefix) {
+        List<Map<String, Object>> items = new ArrayList<>(List.of(item(1), item(2)));
+        vars(prefix).put("order", new HashMap<>(Map.of("items", items)));
+        assertPaths(track(prefix + "order.items"),
+                prefix + "order.items[0]", prefix + "order.items[1]");
+
+        items.get(0).put("qty", 9);
+        assertPaths(track(prefix + "order.items"), prefix + "order.items[0]");
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = {"", "root."})
+    void explicitArrayInNestedObject(String prefix) {
+        List<Map<String, Object>> items = new ArrayList<>(List.of(item(1), item(2)));
+        vars(prefix).put("order", new HashMap<>(Map.of("items", items)));
+        assertPaths(track(prefix + "order.items[].qty"),
+                prefix + "order.items[0].qty", prefix + "order.items[1].qty");
+
+        items.get(1).put("qty", 5);
+        ArrayNode changes = track(prefix + "order.items[].qty");
+        assertPaths(changes, prefix + "order.items[1].qty");
+        assertThat(changes.get(0).get("oldValue").asInt()).isEqualTo(2);
+        assertThat(changes.get(0).get("newValue").asInt()).isEqualTo(5);
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = {"", "root."})
+    void nestedArraysExplicit(String prefix) {
+        List<Map<String, Object>> orders = nestedOrders();
+        vars(prefix).put("orders", orders);
+        assertPaths(track(prefix + "orders[].items[].qty"),
+                prefix + "orders[0].items[0].qty", prefix + "orders[0].items[1].qty",
+                prefix + "orders[1].items[0].qty");
+
+        item(orders, 1, 0).put("qty", 99);
+        ArrayNode changes = track(prefix + "orders[].items[].qty");
+        assertPaths(changes, prefix + "orders[1].items[0].qty");
+        assertThat(changes.get(0).get("oldValue").asInt()).isEqualTo(3);
+        assertThat(changes.get(0).get("newValue").asInt()).isEqualTo(99);
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = {"", "root."})
+    void bareTailAfterExplicitArray(String prefix) {
+        List<Map<String, Object>> orders = nestedOrders();
+        vars(prefix).put("orders", orders);
+        assertPaths(track(prefix + "orders[].items"),
+                prefix + "orders[0].items[0]", prefix + "orders[0].items[1]",
+                prefix + "orders[1].items[0]");
+
+        item(orders, 0, 1).put("qty", 7);
+        assertPaths(track(prefix + "orders[].items"), prefix + "orders[0].items[1]");
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = {"", "root."})
+    void bareArrayOfArrays(String prefix) {
+        List<List<Integer>> matrix = new ArrayList<>(List.of(
+                new ArrayList<>(List.of(1, 2)), new ArrayList<>(List.of(3))));
+        vars(prefix).put("matrix", matrix);
+        assertPaths(track(prefix + "matrix"),
+                prefix + "matrix[0][0]", prefix + "matrix[0][1]", prefix + "matrix[1][0]");
+
+        matrix.get(0).set(1, 20);
+        ArrayNode changes = track(prefix + "matrix");
+        assertPaths(changes, prefix + "matrix[0][1]");
+        assertThat(changes.get(0).get("oldValue").asInt()).isEqualTo(2);
+        assertThat(changes.get(0).get("newValue").asInt()).isEqualTo(20);
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = {"", "root."})
+    void explicitArrayOfArrays(String prefix) {
+        List<List<Integer>> matrix = new ArrayList<>(List.of(
+                new ArrayList<>(List.of(1, 2)), new ArrayList<>(List.of(3))));
+        vars(prefix).put("matrix", matrix);
+        assertPaths(track(prefix + "matrix[][]"),
+                prefix + "matrix[0][0]", prefix + "matrix[0][1]", prefix + "matrix[1][0]");
+
+        matrix.get(1).set(0, 30);
+        assertPaths(track(prefix + "matrix[][]"), prefix + "matrix[1][0]");
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = {"", "root."})
+    void growAndShrinkBareArray(String prefix) {
+        List<String> status = new ArrayList<>(List.of("a"));
+        vars(prefix).put("status", status);
+        track(prefix + "status");
+
+        status.add("b");
+        ArrayNode grown = track(prefix + "status");
+        assertPaths(grown, prefix + "status[1]");
+        assertThat(grown.get(0).get("oldValue").isNull()).isTrue();
+        assertThat(grown.get(0).get("newValue").asText()).isEqualTo("b");
+
+        status.remove(1);
+        ArrayNode shrunk = track(prefix + "status");
+        assertPaths(shrunk, prefix + "status[1]");
+        assertThat(shrunk.get(0).get("oldValue").asText()).isEqualTo("b");
+        assertThat(shrunk.get(0).get("newValue").isNull()).isTrue();
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = {"", "root."})
+    void shapeChangeBetweenScalarAndArray(String prefix) {
+        vars(prefix).put("status", "x");
+        track(prefix + "status");
+
+        // scalar -> array: the element appears, the scalar entry is retired
+        vars(prefix).put("status", new ArrayList<>(List.of("a")));
+        assertPaths(track(prefix + "status"), prefix + "status[0]", prefix + "status");
+
+        // array -> scalar: the scalar reappears, the element entry is retired
+        vars(prefix).put("status", "y");
+        assertPaths(track(prefix + "status"), prefix + "status", prefix + "status[0]");
+    }
+
+    // -------------------------------------------------------------------------
+    // Local-only edge cases
+    // -------------------------------------------------------------------------
+
+    @Test
+    void nonArrayValueWithExplicitBracketsExpandsToNothing() {
+        localVars.put("status", "notAnArray");
+        assertThat(track("status[]")).isEmpty();
+    }
+
+    @Test
+    void emptyArrayTracksNothing() {
+        localVars.put("status", new ArrayList<>());
+        assertThat(track("status")).isEmpty();
+    }
+
+    // -------------------------------------------------------------------------
+    // Helpers
+    // -------------------------------------------------------------------------
+
+    private Map<String, Object> vars(String prefix) {
+        return prefix.isEmpty() ? localVars : rootVars;
+    }
+
+    private ArrayNode track(String csv) {
+        return varUtil.trackVars(scope, "snap", csv);
+    }
+
+    private static void assertPaths(ArrayNode changes, String... paths) {
+        assertThat(changes).extracting(c -> c.get("path").asText())
+                .containsExactlyInAnyOrder(paths);
+    }
+
+    /** [{items:[{qty:1},{qty:2}]}, {items:[{qty:3}]}] as mutable lists/maps. */
+    private static List<Map<String, Object>> nestedOrders() {
+        List<Map<String, Object>> orders = new ArrayList<>();
+        orders.add(new HashMap<>(Map.of("items", new ArrayList<>(List.of(item(1), item(2))))));
+        orders.add(new HashMap<>(Map.of("items", new ArrayList<>(List.of(item(3))))));
+        return orders;
+    }
+
+    private static Map<String, Object> item(int qty) {
+        Map<String, Object> m = new HashMap<>();
+        m.put("qty", qty);
+        return m;
+    }
+
+    @SuppressWarnings("unchecked")
+    private static Map<String, Object> item(List<Map<String, Object>> orders, int order, int item) {
+        return ((List<Map<String, Object>>) orders.get(order).get("items")).get(item);
+    }
+}
diff --git a/customer-work/src/test/resources/application.properties b/customer-work/src/test/resources/application.properties
index 50bda6c..c888e3d 100644
--- a/customer-work/src/test/resources/application.properties
+++ b/customer-work/src/test/resources/application.properties
@@ -11,7 +11,7 @@ management.elastic.metrics.export.enabled=false
 
 # Set debug level in tests
 logging.level.com.flowable=INFO
-logging.level.com.flowable.local.work.model.FlowableModelTestUtils=INFO
+logging.level.com.customer.work.model.FlowableModelTestUtils=INFO
 
 # Disable the timeout process in the tests
 flowable.external-system.wechat.timeout.process-definition-key=
@@ -21,4 +21,16 @@ flowable.app.resource-location=classpath*:/test-auto-deploy-apps/
 
 # Email
 flowable.mail.server.host=localhost
-flowable.mail.server.port=3025
\ No newline at end of file
+flowable.mail.server.port=3025
+
+# REST: incoming calls (simulated against the Flowable REST API)
+test.rest.in.base-url=http://localhost:8105
+test.rest.in.username=admin
+test.rest.in.password=test
+
+# REST: outgoing calls from models go to the test REST server
+# (service models resolve ${propertyConfigurationService.getProperty('customer.serverUrl', ...)})
+customer.serverUrl=http://localhost:18085
+test.rest.out.base-url=${customer.serverUrl}
+test.rest.out.username=admin
+test.rest.out.password=test
\ No newline at end of file
diff --git a/customer-work/src/test/resources/test-auto-deploy-apps/TST_APP.zip b/customer-work/src/test/resources/test-auto-deploy-apps/TST_APP.zip
index f1070c283ae4373371c79a3e5a5726221c5cbd2c..a0d36df14338e88d68e55de84f7c35582e2f55aa 100644
GIT binary patch
delta 16687
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
M5S)%g{@UOF2OOeE6aWAK

delta 28365
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

diff --git a/customer-work/src/test/resources/test-auto-deploy-apps/trackVarsApp.zip b/customer-work/src/test/resources/test-auto-deploy-apps/trackVarsApp.zip
index 21cb2acd1414692fa5c4021ea1a0e6a8e035ee13..9c3a899c4e7b4be1cf266098637f59b73091524b 100644
GIT binary patch
delta 7931
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
F{U5$dz&Zc`

delta 7967
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
AJ^%m!