Sync ako/mxcli: page round-trip fixes, label widget, OData expressions, layout flows

.claude/lint-rules/conv009_max_microflow_objects.star

@@ -18,15 +18,15 @@ def check():
     for mf in microflows():
         if mf.activity_count > MAX_ACTIVITIES:
             violations.append(violation(
-                message="Microflow '{}' has {} activities (convention max: {}). Split into sub-microflows.".format(
-                    mf.name, mf.activity_count, MAX_ACTIVITIES
+                message="{} '{}' has {} activities (convention max: {}). Split into sub-{}s.".format(
+                    mf.document_noun_title, mf.name, mf.activity_count, MAX_ACTIVITIES, mf.document_noun
                 ),
                 location=location(
                     module=mf.module_name,
-                    document_type="Microflow",
+                    document_type=mf.document_noun_title,
                     document_name=mf.qualified_name,
                 ),
-                suggestion="Extract logical sections into SUB_ microflows to keep each under {} activities".format(MAX_ACTIVITIES),
+                suggestion="Extract logical sections into SUB_ {}s to keep each under {} activities".format(mf.document_noun, MAX_ACTIVITIES),
             ))
 
     return violations

.claude/lint-rules/conv010_act_microflow_content.star

@@ -92,31 +92,31 @@ def check():
                     continue
 
                 violations.append(violation(
-                    message="ACT_ microflow '{}' contains '{}' action. Delegate business logic to a SUB_ microflow.".format(
-                        mf.name, act.action_type
+                    message="ACT_ {} '{}' contains '{}' action. Delegate business logic to a SUB_ {}.".format(
+                        mf.document_noun, mf.name, act.action_type, mf.document_noun
                     ),
                     location=location(
                         module=mf.module_name,
-                        document_type="Microflow",
+                        document_type=mf.document_noun_title,
                         document_name=mf.qualified_name,
                     ),
-                    suggestion="Move the '{}' action to a SUB_ microflow and call it from '{}'".format(
-                        act.action_type, mf.name
+                    suggestion="Move the '{}' action to a SUB_ {} and call it from '{}'".format(
+                        act.action_type, mf.document_noun, mf.name
                     ),
                 ))
             elif act.activity_type not in ALLOWED_ACTIVITY_TYPES:
                 # Any other non-allowed activity type
                 violations.append(violation(
-                    message="ACT_ microflow '{}' contains '{}' activity. Delegate to a SUB_ microflow.".format(
-                        mf.name, act.activity_type
+                    message="ACT_ {} '{}' contains '{}' activity. Delegate to a SUB_ {}.".format(
+                        mf.document_noun, mf.name, act.activity_type, mf.document_noun
                     ),
                     location=location(
                         module=mf.module_name,
-                        document_type="Microflow",
+                        document_type=mf.document_noun_title,
                         document_name=mf.qualified_name,
                     ),
-                    suggestion="Move the '{}' to a SUB_ microflow called from '{}'".format(
-                        act.activity_type, mf.name
+                    suggestion="Move the '{}' to a SUB_ {} called from '{}'".format(
+                        act.activity_type, mf.document_noun, mf.name
                     ),
                 ))
 

.claude/lint-rules/example_microflow.star

@@ -14,11 +14,13 @@
 #   .name            - Simple name (e.g., "ACT_ProcessOrder")
 #   .qualified_name  - Full name (e.g., "MyModule.ACT_ProcessOrder")
 #   .module_name     - Module name
-#   .microflow_type  - "Microflow" or "Nanoflow"
+#   .microflow_type  - "MICROFLOW", "NANOFLOW" or "RULE"
 #   .description     - Documentation
 #   .return_type     - Return type
 #   .parameter_count - Number of parameters
 #   .activity_count  - Number of activities
+#   .document_noun   - "microflow", "nanoflow" or "rule" (microflows() yields all three)
+#   .document_noun_title - the same, capitalised: use it for document_type=
 
 RULE_ID = "CUSTOM002"
 RULE_NAME = "Microflow Prefix Convention"
@@ -48,11 +50,12 @@ def check():
         if not has_valid_prefix:
             loc = location(
                 module=mf.module_name,
-                document_type="Microflow",
+                document_type=mf.document_noun_title,
                 document_name=mf.qualified_name
             )
             v = violation(
-                message="Microflow '{}' should start with a standard prefix ({})".format(
+                message="{} '{}' should start with a standard prefix ({})".format(
+                    mf.document_noun_title,
                     name,
                     ", ".join(VALID_PREFIXES)
                 ),

.claude/lint-rules/long_microflows.star

@@ -31,14 +31,16 @@ def check():
         if mf.activity_count > MAX_ACTIVITIES:
             loc = location(
                 module=mf.module_name,
-                document_type="Microflow",
+                document_type=mf.document_noun_title,
                 document_name=mf.qualified_name
             )
             v = violation(
-                message="Microflow '{}' has {} activities (max: {}). Consider splitting into smaller microflows.".format(
+                message="{} '{}' has {} activities (max: {}). Consider splitting into smaller {}s.".format(
+                    mf.document_noun_title,
                     mf.name,
                     mf.activity_count,
-                    MAX_ACTIVITIES
+                    MAX_ACTIVITIES,
+                    mf.document_noun
                 ),
                 location=loc,
                 suggestion="Extract logical sections into SUB_ microflows. This improves readability, testability, and reusability."

.claude/lint-rules/mccabe_complexity.star

@@ -18,12 +18,14 @@
 #   .name            - Simple name (e.g., "ProcessOrder")
 #   .qualified_name  - Full name (e.g., "MyModule.ProcessOrder")
 #   .module_name     - Module name
-#   .microflow_type  - "MICROFLOW" or "NANOFLOW"
+#   .microflow_type  - "MICROFLOW", "NANOFLOW" or "RULE"
 #   .description     - Documentation
 #   .return_type     - Return type
 #   .parameter_count - Number of parameters
 #   .activity_count  - Number of activities
 #   .complexity      - McCabe cyclomatic complexity
+#   .document_noun   - "microflow", "nanoflow" or "rule" (microflows() yields all three)
+#   .document_noun_title - the same, capitalised: use it for document_type=
 
 RULE_ID = "QUAL001"
 RULE_NAME = "McCabe Complexity"
@@ -45,14 +47,16 @@ def check():
         if mf.complexity > MAX_COMPLEXITY:
             loc = location(
                 module=mf.module_name,
-                document_type="Microflow",
+                document_type=mf.document_noun_title,
                 document_name=mf.qualified_name
             )
             v = violation(
-                message="Microflow '{}' has complexity {} (max: {}). Consider splitting into smaller microflows.".format(
+                message="{} '{}' has complexity {} (max: {}). Consider splitting into smaller {}s.".format(
+                    mf.document_noun_title,
                     mf.name,
                     mf.complexity,
-                    MAX_COMPLEXITY
+                    MAX_COMPLEXITY,
+                    mf.document_noun
                 ),
                 location=loc,
                 suggestion="Break down complex logic into sub-microflows. Extract decision branches into separate SUB_ microflows."

.claude/lint-rules/orphaned_elements.star

@@ -89,11 +89,11 @@ def check():
         if not has_callers:
             loc = location(
                 module=mf.module_name,
-                document_type="Microflow",
+                document_type=mf.document_noun_title,
                 document_name=mf.qualified_name
             )
             v = violation(
-                message="Microflow '{}' is not called from anywhere.".format(mf.name),
+                message="{} '{}' is not called from anywhere.".format(mf.document_noun_title, mf.name),
                 location=loc,
                 suggestion="Remove if unused, or rename with ACT_/SCH_ prefix if it's an entry point."
             )

.claude/skills/fix-issue/findings/cmd-mxcli.jsonl

@@ -126,3 +126,5 @@
 {"area": "cmd/mxcli/diag", "date": "2026-09-23", "symptom": "`mxcli diag loop-report` showed all 5 `test` runs as 'did not close' although every test passed, and inflated the `-c` (111) and `exec` (180) counts in the same log. Reported as 'the command apparently skips the summary record on success too' \u2014 which is not what happens: `test` returns normally, PersistentPostRun fires, and the session_end IS written.", "cause": "mxcli runs mxcli. Measured from a real `mxcli test` with MXCLI_LOG_DIR pointed at a scratch dir: one parent session_start (pid 1071) followed by THREE child session_starts \u2014 `-c DESCRIBE SETTINGS`, `-c SHOW MODULES`, and an `exec` of the generated runner \u2014 before a single test executes. `new`, `eval`, `tui` and the LSP self-spawn the same way (six os.Executable() sites). buildInvocations segmented on 'next session_end OR next session_start, whichever comes first', so a child's start closed the parent's invocation and the parent's own end landed on whatever was open by then. session_end carried no pid, so pairing by process was impossible.", "file": "`mdl/diaglog/diaglog.go` (pid on session_end; parentPIDEnv marker set once in Init and inherited by every child), `cmd/mxcli/diag_loop_report.go` (buildInvocations pairs by pid with the positional rule as fallback; spawned runs excluded from the table and wall time, counted on their own line), tests `cmd/mxcli/diag_loop_report_test.go`", "insight": "The segmentation rule documented itself as exact 'for sequential invocations, which is what an agent loop produces' \u2014 and the thing that breaks that assumption is the tool itself, not concurrency by the user. When a tool can invoke itself, EVERY per-process measurement over it needs a parent link, not just a pid: a pid alone fixes the pairing but still counts three phantom agent calls per test run. The marker belongs on the ENVIRONMENT, not at each spawn site: exec.Command inherits the parent's environment (explicitly via os.Environ(), implicitly when Cmd.Env is nil), so one os.Setenv in Init covers all six self-spawn sites and any added later \u2014 six edits that would each have to be remembered become zero. Second-order trap: spawned runs must be excluded from WALL TIME too, not just the count, because a child's seconds are already inside its parent's; the test asserts 10s for a parent with three 1s children, and the reverted code says 3. Prove-by-revert done on the measured record shape: the positional rule gives Invocations=4 (want 1), Unclosed=1 for a parent whose tests all passed, Wall=3 (want 10).", "refs": ["ako/mxcli#617", "ako/mxcli#629"]}
 {"area": "cmd/mxcli/syntax", "date": "2026-09-23", "symptom": "`mxcli syntax page datasource` documented `DataSource: MICROFLOW Module.MF($P)`. That form is a parse error: `dataview dv (datasource: microflow M.DS_X($State))` gives 'line 2:15 no viable alternative at input datasource'. Only the NAMED form `M.DS_X(State: $State)` parses. Hit in a real build, diagnosed from the error rather than the doc.", "cause": "The syntax entry was written from the intended shape rather than from something that had been run through the parser. Nothing checks it: the Syntax and Example fields are free text.", "file": "`cmd/mxcli/syntax/features_page.go` (page.datasource entry now shows `MICROFLOW Module.MF(Param: $P)` and states that the positional form is a parse error)", "insight": "CLAUDE.md deliberately points at `mxcli syntax` instead of restating syntax, so that it cannot go stale \u2014 which makes a wrong entry there worse than a wrong entry in prose, because it is the thing consulted INSTEAD of checking. The cost lands in the agent loop: read it, write it, fail to parse, diagnose, retry. Measured before reaching for the systemic guard: 42 of 164 syntax examples fail `mxcli check` today, but the large majority are fragments by design (a microflow body like `IF \u2026`, a widget snippet like `DATAGRID \u2026`, an OQL fragment) and are legitimately not standalone top-level MDL \u2014 so a blanket 'every example must parse' test would be mostly noise, and making it useful needs a way to mark which examples are standalone. Measuring that first is what stopped a plausible-sounding guard from being built wrong.", "refs": ["ako/mxcli#630"]}
 {"area": "cmd/mxcli/test", "date": "2026-09-23", "symptom": "Windows: `mxcli test tests/ -p MyApp.mpr --local` fails with `local runtime: starting mxbuild serve: mxbuild --serve did not become ready` after caching a Linux ELF in %USERPROFILE%\\.mxcli\\mxbuild, and there is \"no flag, environment variable, or mechanism to redirect mxcli to the Windows mxbuild.exe already present in the Studio Pro installation\"", "cause": "Two layers. The platform part (downloading/exec'ing the Linux binary, serving from the cache instead of the resolved binary) was already fixed by #916 and #1122, both after the reporter's v0.21.0. What remained on main: `test` never registered `--mxbuild-path` — `run` gained it in #1125, but `test --local` boots through the same `ResolveMxBuildForLocal` and prints the same 'pass --mxbuild-path' guidance while answering `unknown flag`. `RunOptions` had no field and `localAppOptions` never set `LocalAppOptions.MxBuildPath`, though StartLocalApp honoured it. No env override existed anywhere", "file": "`cmd/mxcli/main.go` + `cmd_test_run.go` (flag), `testrunner/runner.go` + `localapp_options.go` (plumbing), `docker/mxbuild_platform.go` (`MxBuildPathEnv`, read in `resolveMxBuildForLocalOn` after the flag)", "insight": "**The guard for #1125 asserted its invariant against one command** — `TestErrorGuidanceNamesAFlagThatExists` checked only `runCmd`, while the guidance it polices is emitted by a resolver two commands share. When a test pins 'the advertised flag exists', enumerate the callers of the code that ADVERTISES it, not the command the report named; it now iterates `run` and `test`. **Before fixing a platform report, date it against the fixes**: the reporter's first two suggestions ('download platform-correct binary', 'auto-discover Studio Pro') were already on main, and re-implementing them would have been churn — only the override was missing. Put the env var in the resolver, not the CLI, so `run --local` and `test --local` both get it from one line; a flag-level env read would have been one more per-command copy to drift. Control: the env test runs as goos=windows with an unmatched version, so without the override it fails fast with the 'Linux binary cannot run natively on windows' refusal instead of hitting the CDN; removing only the `MxBuildPath:` line in localAppOptions fails the plumbing test for both runners. **Unverified**: no Windows host; code-level with OS-injected tests", "refs": ["mendixlabs/mxcli#1086", "mendixlabs/mxcli#1125", "mendixlabs/mxcli#916", "mendixlabs/mxcli#1122"]}
+{"area": "cmd/mxcli", "date": "2026-09-25", "symptom": "Shipped Starlark rules CONV009, CONV010, QUAL001, QUAL003, QUAL004 and CUSTOM002 report nanoflows and rules as microflows: \"Microflow 'NF_Foo' has 30 activities\", and documentType \"Microflow\" in the JSON and report output.", "cause": "microflows() yields all three flow flavours (one catalog table, MicroflowType MICROFLOW/NANOFLOW/RULE), and each rule hardcoded document_type=\"Microflow\" and a \"Microflow '...'\" message. The Go rules had already been fixed with Microflow.DocumentNoun() after MPR002 called a rule a microflow, but that method was never exposed to Starlark, so every Starlark rule had to re-derive it and none did.", "file": "mdl/linter/starlark.go, .claude/lint-rules/{conv009_max_microflow_objects,conv010_act_microflow_content,example_microflow,long_microflows,mccabe_complexity,orphaned_elements}.star, mdl/linter/starlark_flow_noun_test.go", "insight": "When a Go-side fix lives in a method, check whether the Starlark projection can reach it; a fix Starlark cannot call is a fix for half the rules. Exposed as document_noun / document_noun_title on the microflow struct, and the test runs every shipped rule over a fixture with one flow per flavour, requiring a finding on each (else vacuous) plus a guard that any new `for x in microflows()` rule joins the list. Skip the wrong turn of excluding nanoflows/rules from QUAL004: rule calls from decisions ARE emitted as 'call' refs (builder_references.go collectRuleCalls), so only the label was wrong.", "refs": "mendixlabs/mxcli#1178"}
+{"area": "cmd/mxcli", "date": "2026-09-25", "symptom": "Starlark rule API docs name microflow_type values the linter never returns: the write-lint-rules skill said \"microflow\"/\"nanoflow\", example_microflow.star (copied into every project by mxcli init) said \"Microflow\"/\"Nanoflow\", only mccabe_complexity.star had \"MICROFLOW\"/\"NANOFLOW\", and none listed \"RULE\". The skill's entity table also omitted has_created_date/has_changed_date/has_owner/has_changed_by.", "cause": "LintContext.Microflows() passes the catalog's MicroflowType through raw (MICROFLOW/NANOFLOW/RULE) while Entities() CASE-normalizes EntityType to TitleCase, so the two adjacent iterators have opposite conventions and each doc author guessed. Nothing tied the documented literals to what the API emits, so two passes over the same skill file (59db6e7b, #1165) fixed instances and left this one.", "file": ".claude/skills/mendix/write-lint-rules/SKILL.md, .claude/lint-rules/example_microflow.star, .claude/lint-rules/mccabe_complexity.star, mdl/linter/starlark_documented_values_test.go", "insight": "Fix the class, not the row: observe the emitted field names and enum values by running a Starlark rule (dir(e), e.entity_type) over a fixture holding every stored kind, then assert the skill tables, the shipped rules' `# .field - ...` headers, and every `.entity_type/.microflow_type ==` comparison in shipped rules against that observed set. Equality, not subset, for the docs -- an undocumented value (RULE) is a flavour a rule silently mistreats. Normalizing MicroflowType instead would have broken every user rule already comparing \"MICROFLOW\" correctly.", "refs": "mendixlabs/mxcli#1178, mendixlabs/mxcli#1164"}