LRAM: Rebuilding Large Action Models with xLSTM

0. Link verification table

All URLs below were visited on 2026-10-08. Numerical evidence prioritizes the ICML/arXiv v3 PDF; aggregators serve only discovery and cross-checking, not experimental numbers.

1. Candidate pool, deduplication, and random selection

First read ml-report-index.md. BridgeVLA, PointMapPolicy, and Among Us were covered in the preceding 14 days; Embodied-R1 and VIKI-R were reviewed in mid-September. They respectively cover three-view VLA action heads, structured point-cloud imitation, agentic deception, geometrically verifiable RL, and multirobot collaboration, and were excluded. ACL Anthology, arXiv, ICML/PMLR, NeurIPS, OpenReview, Hugging Face Daily Papers, Semantic Scholar, and Papers with Code supported discovery or verification. Final candidates prioritized 2025–2026 main-conference papers with fuller official versions, appendices, and tables.

Actually executed shuf -i 1-24 -n 1returned 11. The paper is within 24 months, belongs to ICML 2025's main conference, and has sufficient full-text and code resources, so it was adopted on the first draw, without redrawing. Randomness determines only the core paper, not the subsequent standards for checking numbers and limitations.

2. Motivation: Control Loops Cannot Wait for Quadratic Complexity

Latency in robotic control is more than a faster user experience. The paper cites common control frequencies for industrial arms and drones of 100–1000 Hz, requiring policy inference below 10 ms; at 1000 Hz, 15 seconds of action creates a history of 15,000 steps(PDF pp.1–2). Keeping every time step in a Transformer KV cache makes per-step computation approximately linear in context despite caching, while cumulative rollout cost and memory grow quickly. On an A100 40GB with 206M parameters and long Freeway trajectories, DT latency and memory rise with context and eventually OOM at larger contexts/batches. xLSTM and Mamba maintain fixed-size recurrent states and nearly context-independent latency (Figures 6–7, PDF pp.7–8).

Action data also does not naturally fit language-style tokenization. LRAM combines six environment families: Atari and Procgen use image observations and discrete actions; Meta-World, DMControl, Composuite, and Mimicgen use low-dimensional states and continuous actions. The paper collects 432 training tasks, 37 held-out tasks, 3.4M trajectories, and 894M transitions(Table 1, PDF p.4). Patchifying continuous states and generating action dimensions autoregressively lengthen sequences and require repeated forward passes per control step, allowing output heads to consume the latency budget.

A third, counterintuitive problem is that historical actions are easy labels to copy. Adjacent-action MSE is only 0.08±0.09on Meta-World and 0.20±0.22on DMControl, far below Composuite's 2.10±0.30(Table 7, PDF p.32). Copying the previous action can minimize training loss while amplifying initial errors in closed-loop control. The authors therefore remove action inputs, retaining state, return-to-go (RTG), and reward. This changes conditioning as well as architecture.

The central question becomes:Can large-scale parallel training be retained while fixed-size recurrent states replace growing KV caches and one shared head handles both discrete and continuous control? LRAM answers with xLSTM, but bundles backbone improvements, action removal, and a faster shared head. These factors must be examined separately.

3. Argument, assumptions, and trade-offs

The paper's story has five steps.

1. Retain Decision Transformer's upside-down RL: model offline trajectories as conditional sequence prediction without value fitting or online policy gradients, injecting target returns through RTG.
2. Unify inputs across domains: use small CNNs for images and linear layers for low-dimensional states, rewards, and RTG, avoiding sequence inflation from visual patches and continuous-state tokenization (§3.2, PDF p.4).
3. Remove historical actions: prevent copycat shortcuts in smooth-action domains so long contexts carry useful state/return information.
4. Use a shared action head: discretize each continuous action dimension into 256 uniform bins; predict up to 8 continuous dimensions and 18 discrete actions through one parallel head, trained with cross-entropy (§3.2, PDF p.4).
5. Train in parallel, deploy recurrently: xLSTM/Mamba process 150-token contexts in parallel during training; deployment retains only the previous hidden state rather than rereading the full history.

Three assumptions underlie the approach: recurrent backbones retain performance at scale; six-domain mixtures with equal domain sampling represent generalist action models; and A100 custom-kernel gains transfer to robotic edge devices. Experiments support the first, partially support the second, and barely test the third.

The tradeoffs are explicit. xLSTM[1:0] uses only mLSTM, parallelizes most easily, and has stronger average performance across the main 432 tasks. xLSTM[7:1] adds sLSTM for state tracking and performs better on partially observable tasks such as Dark-Room, but sLSTM is not fully parallel. Transformers retain advantages in exact token recall. The conclusion acknowledges task-dependent backbone choice rather than universal replacement of attention (§5, PDF p.9).

4. Equations, Workflow, and Pseudocode

Write an offline trajectory as

τ_i=(s_1, R̂_1, a_1, r_1, …, s_T, R̂_T, a_T, r_T), where R̂_t=Σ_{t'=t}^T r_{t'}。

The original multigame Decision Transformer learns (Equation 1, PDF p.3):

â_t ~ π_θ(· | s_{t-C},R̂_{t-C},a_{t-C},r_{t-C}, …, s_t,R̂_t)。

Removing action conditioning gives LRAM (Equation 2, PDF p.4):

â_t ~ π_ρ(· | s_{t-C},R̂_{t-C},r_{t-C}, …, s_{t-1},R̂_{t-1},r_{t-1},s_t,R̂_t)。

For discrete actions, the head directly outputs p(a_t=k|h_t); for continuous dimension j , quantize into 256 bins as b_{t,j}, yielding total loss

L(ρ)=−Σ_t [ Σ_{j∈cont} log p_ρ(b_{t,j}|h_t) + Σ_{k∈disc} 1[a_t=k]log p_ρ(k|h_t) ]。

This equivalently expands the paper's cross-entropy implementation without adding unreported loss terms. Recurrent inference updates can be abstracted as h_t=F_ρ(h_{t−1},x_t); a Transformer instead stores K_{≤t},V_{≤t}. xLSTM's per-step state cost is independent of history length, whereas DT's cache grows with t .

Training (parallel):
  Sample equally across six domains: 128 per domain, effective batch 768 after gradient accumulation
  Crop C=50 timesteps (state / RTG / reward per step, 150 tokens total)
  Encode images or low-dimensional states; omit historical actions
  Produce hidden sequences with parallel xLSTM
  Shared head predicts discrete actions or 256-bin outputs for up to 8 continuous dimensions at once
  Backpropagate cross-entropy; AdamW, 200K updates

Deployment (recurrent):
  Initialize hidden state h0
  Each control cycle:
    Input current state, updated RTG, and previous reward
    h_t ← recurrent_xLSTM(h_{t−1}, token_t)
    logits ← shared_action_head(h_t)
    Select a discrete action or dequantize each continuous dimension from 256 bins
    Execute action and retain h_t; do not replay the full context

5. Key mechanisms and engineering details

A notable reproducibility conflict: Appendix C.1 says no Dropout is used, and Appendix E.4 says the default 0.1 Dropout is removed, but Table 5 lists Dropout=0.2(arXiv HTML lines 540–560, PDF p.21). This is a consequential hyperparameter for continuous control, not a wording preference, and must be flagged as unresolved.

6. Datasets, benchmarks, and metrics

Table 1's Repetitions column shows uneven data exposure: Mimicgen 8.5×，Meta‑World 2.34×，Composuite 0.87×. Equal weighting across six domains causes smaller datasets to be reused. Thus, 894M transitions does not mean each example is seen once; Mimicgen oversampling may improve fitting or amplify small-data bias.

The main figure normalizes domains before averaging equally, useful for overall trends but masking raw scales and task difficulty. The matrix below retains each domain's raw mean without summing across rows; units are not interchangeable.

7. Main Results: Four Methods, Without Inventing Six

At a unified 206M scale, the paper compares only four backbones: DT, Mamba, xLSTM[1:0], and xLSTM[7:1], not six methods. The following 6-row × 4-method matrix is individually verifiable from appendix tables, with no invented baselines. Bold denotes the row best.

Sources: appendix Table 8 (PDF p.37), Table 9 (p.38), Table 10 (p.39), Table 11 (p.40), and Table 12 (p.41). Meta-World contradicts universal recurrent-backbone superiority: DT's 1486.05 exceeds xLSTM[7:1] by 21.89. Atari and DMControl support architectural gains, but favor different mixtures: pure mLSTM wins Atari, mixed sLSTM wins DMControl.

7.1 Per-task variance matters

On DMControl, finger-turn-easy improves from DT's 121.27±104.60 to xLSTM[7:1]'s 640.13±82.48, but walker-run falls from DT's 155.91±73.84 to xLSTM[7:1]'s 145.01±31.71;reacher-easy is highest for Mamba at 180.70±133.64 , while xLSTM[7:1] achieves only 58.00±13.91 (Table 11). The average +43.35% is driven by large gains on some tasks, not universal suitability for every control dynamic.

7.2 Efficiency: Strong directional conclusions, weak exact speed ratios

Figure 6 compares 206M models on A100 over C=50…25600 timesteps, each containing 3 tokens, at batch sizes 1 or 16. xLSTM latency is nearly flat; DT grows with context and eventually OOMs. Figure 7's C=1600 throughput likewise shows DT OOM at batch>64, while recurrent backbones reach 128. Exact bar values are not tabulated, so this report does not invent an X× speedup from pixels. The supported conclusion is:Under this A100/Freeway/custom-kernel setup, xLSTM supports larger contexts and batches and has lower long-context latency; no fixed multiplier on arbitrary edge hardware follows.

8. Layered ablations, hyperparameter sensitivity, and transitions

8.1 Removing actions: The largest modeling change

A single-seed ablation over all 432 tasks with 206M DT shows that with historical actions, increasing context from 1 to 50 leaves average normalized score near 0.3; removing actions changes it from roughly 0.3 to 0.7(Figure 24, PDF p.30). xLSTM[1:0] similarly moves from C=1 approximately 0.4 to C=50 approximately 0.8(Figure 26, PDF p.31). The transition is not that longer is always better, but that long context becomes informative only after removing the copyable action shortcut。

This ablation uses one seed, explicitly due to computation limits (Appendix E.1.2). The 0.3→0.7 and 0.4→0.8 changes are strong trends, not precise effect sizes with confidence intervals.

8.2 mLSTM / sLSTM ratios: Task properties determine the optimum

In the 16M ablation on 432 tasks, pure mLSTM [1:0] outperforms sLSTM variants on average. The authors attribute this to mostly fully observable environments with limited state-tracking needs. In 10×10 Dark-Room with 80 training / 20 held-out goals, inserting sLSTM in lower layers as [7:1]@1 with [3:1]@1,3 outperforms pure mLSTM; deep-layer sLSTM or all-sLSTM performs poorly (Figures 30–31, PDF p.36). More sLSTM is not always better:placement and partial observability jointly determine benefits。

8.3 RTG and behavior cloning

At 206M, removing RTG, or additionally reward, largely preserves relative backbone trends (Figures 28–29, PDF pp.32–33), suggesting recurrent advantages are not wholly dependent on return conditioning. However, final performance is explicitly lower than with RTG, so BC transfer supports stable ranking, not preserved absolute capability.

8.4 Kernels, head counts, and layers

Each xLSTM timestep contains 3 tokens: ordinary recurrent execution needs 3 forwards, while a chunkwise kernel needs one. Figure 21 shows that at batch=1, even kernel-free chunkwise execution beats kernel-enabled token-wise recurrence; with larger batches, the kernel advantage reverses (Appendix D.5.3, PDF p.30). Figure 22 shows throughput rising as heads increase from 4 to 32 at fixed hidden dimension, reducing per-head dimensions and FLOPs (PDF p.28). Halving xLSTM's layers and widening hidden states to match DT parameters slightly reduces performance but still beats DT (Figure 33, PDF p.35). Speed is therefore jointly determined by architecture × kernel × head geometry .

8.5 Dropout conflict

The authors say DT's default 0.1 Dropout substantially harms Composuite and is removed in main experiments (Appendix E.4), but Table 5 lists Dropout 0.2. The repository README's commands do not clearly override it. Given continuous control's sensitivity to Dropout, optimal tuning of the DT baseline remains uncertain until this conflict is resolved.

9. Statistical Significance: What Is Supported and What Is Not

According to Appendix C.1, main experiments report means and 95% confidence intervals over 3 training seeds, additionally averaging 3 evaluation seeds per task. This is stronger than many single-seed large action-model studies. The many mean± entries in Tables 10–12 also expose task-level variation.

However, statistics do not cover all key claims: 408M scaling has only 1 run; full-task context-length ablations have only 1 seed per length; mLSTM:sLSTM ratio ablations also have only 1 seed/ratio. Latency/throughput plots average over 5 episodes while discarding the first, without standard deviations, P95/P99, or multiple-machine repetitions. Six-domain multiple comparisons are not corrected. Main 16M–206M performance trends have three-seed support, but not all hyperparameter transitions or systems advantages are statistically significant.

10. Contributions, reusable designs, and transfer potential

Contribution 1: Making the backbone of an action foundation model an empirical choice rather than defaulting to attention. Across 432 tasks, six domains, and four model scales under a consistent protocol, xLSTM/Mamba are shown to be competitive large action-model backbones, well beyond an RNN swap on one MuJoCo table.

Contribution 2: Identifying the action-copy shortcut. Removing actions seems contrary to Decision Transformer, but adjacent-action MSE in Table 7 and context ablations form a coherent causal account: smooth actions are easy to copy; copying lowers training loss but harms closed-loop correction; action removal lets long context help. This design may transfer to diffusion policies, VLA action chunking, and other low-jerk control data.

Contribution 3: Treating systems details as part of the model. Shared parallel action heads, fixed recurrent states, chunkwise kernels, and head dimensions directly determine control frequency. Control-model evaluation should report context, batch size, state cache, output-head call counts, and full environment-step latency alongside task success.

LRAM best fits long-trajectory partially observable control with lower-layer sLSTM, online fine-tuning across many parallel simulators, and fixed-memory edge policies. Open-vocabulary VLA transfer still requires language tokens, visual patches, cross-modal attention, and action chunks; the current small-CNN/low-dimensional-state setup does not establish VLA-scale benefits.

11. Related Work: Origins, Gaps, Responses, and Inherited Designs

11.1 Decision Transformer: RL as sequence modeling

Problem addressed: DT predicts actions from causal sequences of desired return, state, and action, without explicit Q-fitting or policy gradients. Its arXiv abstract reports matching or exceeding contemporary model-free offline RL on Atari, Gym, and Key-to-Door.
Remaining gap: long control histories require growing KV caches, while standard conditioning can encourage copycat behavior in smooth-action domains.
LRAM's response: retains RTG conditioning and next-action prediction, replaces caches with recurrent states, and removes historical actions.
Design transfer: DT supplies the trajectory-as-language interface; LRAM revises the backbone and token conditioning while retaining sequence RL.

11.2 Gato: Unifying tasks, modalities, and action vocabularies

Problem addressed: Gato uses shared weights for Atari, text, image captioning, and a real robotic arm, demonstrating a single Transformer across 600+ tasks.
Remaining gap: unified tokenization and autoregressive actions lengthen sequences and inference; training data and weights are not fully public.
LRAM's response: reconstructs a public multitask comparison over 432 tasks in six domains, avoiding visual patchification, continuous-state tokenization, and dimension-wise autoregressive actions.
Design transfer: Gato's shared action vocabulary becomes LRAM's parallel 256-bin shared head.

11.3 Mamba: Selective state spaces and hardware-aware recurrence

Problem addressed: makes SSM parameters input-dependent and uses hardware-aware scans for parallel training and linear sequence complexity.
Remaining gap: action-domain performance and real-time closed-loop behavior were not systematically compared. Here, the Mamba kernel is incompatible with torch.compile and is even slower than DT at batch=1.
LRAM's response: includes Mamba as a strong recurrent baseline under the same tasks, scales, and A100 environment.
Design transfer: parallel training, recurrent deployment, and fixed state complexity directly shape LRAM's evaluation protocol.

11.4 xLSTM: Exponential gating, matrix memory, and state tracking

Problem addressed: introduces exponential gates; mLSTM uses fully parallelizable matrix memory, while sLSTM retains a nondiagonal recurrent matrix for state tracking.
Remaining gap: the original focuses on language modeling, without establishing embodied action quality, real-time performance, or cross-domain scaling.
LRAM's response: applies [1:0] with [7:1] both architectures to 432 tasks and uses Dark-Room to test sLSTM's conditional value under partial observability.
Design transfer: mLSTM provides large-scale throughput, while sparse sLSTM layers track state; lower placement outperforms deep stacking.

11.5 Nonlinear technical evolution tree

Online RL expert trajectories ────────────┐
                                         ├─> Offline trajectories (894M transitions)
Decision Transformer ── RTG conditioning ─┘          │
        │                                            ├─ Remove actions → suppress copycat
        └─ Transformer / KV cache ─ long-context limit┤
                                                     ├─ 256-bin + shared action head
Mamba ─ selective SSM ─ fixed state ─────────────┐   │
                                                ├──> LRAM
xLSTM ─ exponential gates ┬─ mLSTM: parallel matrix memory ┘ │
                          └─ sLSTM: state tracking ─ Dark-Room┘

LRAM ──> Long contexts / high parallel throughput
   ├──> Still missing: real robots, edge hardware, online RL
   └──> Still missing: language-conditioned VLA, action chunks, safety constraints

11.6 Cross-paper comparison

12. Author-Acknowledged Limitations (with Locations)

1. No real-robot experiments: the authors explicitly target robotics, but most experiments use robotic simulators without physical-robot evidence (§5, “Limitations & Future Work”，PDF p.9）。
2. Fine-tuning is offline RL only: online RL to discover policies beyond training data is future work; current fine-tuning remains offline (same section, PDF p.9).
3. ICL is tested only in Dark-Room: improved in-context learning is verified only in a 10×10 grid world, not complex environments (same section, PDF p.9).

13. Independent Critique: Because X, Therefore Y

1. [Causal attribution] LRAM simultaneously replaces the backbone, removes historical actions and timestep encoding, and introduces a shared parallel head. Gains cannot all be attributed to xLSTM; a complete factorial ablation should add each change to the same Transformer.
2. [External validity] All 432 training and 37 held-out tasks are simulations/games, and the authors acknowledge no real robots. Suitability for real-time robotics is currently an extrapolation from systems complexity, not deployment evidence; sensor jitter, communication delays, and safety stops are unmeasured.
3. [Hardware fairness] xLSTM uses a custom kernel and torch.compile, whereas the Mamba kernel is incompatible with torch.compile , and inference is tested only on A100 40GB. Figures 6–7 measure current implementation stacks, not pure architectural limits. Head-to-head tests should include A100, RTX, Jetson, and CPU.
4. [Metric aggregation] Six domains are separately normalized and equally weighted, matching roughly equal training sampling. Mimicgen is repeated about 8.5× versus Composuite's 0.87×. Overall averages therefore hide sample efficiency and task-count differences; micro- and macro-averages, gains per transition, and domain-wise Pareto frontiers are needed.
5. [Performance boundaries] In the 206M raw tables, DT's Meta-World score of 1486.05 exceeds xLSTM[7:1]'s 1464.16 (−1.47%), and Mamba or DT wins several DMControl tasks. Recurrence being better suited to action models is an average trend, not dominance.
6. [Statistical coverage] Main experiments have 3 seeds and 95% CIs, but context-length, mLSTM:sLSTM ratio, and 408M scaling experiments each use 1 seed. The most mechanistically interesting transitions thus lack stability evidence; at least 5 seeds, task-level bootstrap, and multiple-comparison correction are needed.
7. [Reproducibility consistency] The appendix says no Dropout, Table 5 lists 0.2, and E.4 says default 0.1 substantially harms continuous control. DT baseline tuning is therefore unclear. This could change backbone rankings and should be resolved through the configuration commit and final checkpoint metadata.
8. [Safety] The policy imitates offline data through next-action prediction without a constraint layer, OOD detector, or uncertainty-based abstention. The Impact Statement warns of hallucinated actions in unfamiliar settings. Low-latency recurrence could simply execute errors faster; physical deployment needs an action shield and fallback controller.

14. Open challenges: actionable head-to-head experiments

14.1 Theory

• Memory capacity versus control error: over adjustable POMDP memory lengths L∈{16,64,256,1024} , compare DT, Mamba, mLSTM, and lower-layer sLSTM at fixed parameter counts. Measure policy regret, linear probes of hidden states, and forgetting curves. Good probes without good control would leave the state-tracking explanation incomplete.
• Action-copy transition: sweep adjacent-action correlations from 0 to 0.99 with synthetic controllers, comparing action-conditioned and action-free models. Preregister copycat thresholds and closed-loop error growth to test whether Table 7's MSE is a sufficient explanatory variable.
• Multitask interference laws: fix total tokens while varying six-domain weights and task counts. Compare macro return, gradient angles, and representation overlap to identify when equal-domain sampling beats sampling by data volume.

14.2 Engineering and applications

• Real edge-hardware latency: use the same 206M checkpoint and action head on A100, RTX 4090, Jetson AGX Orin, and desktop CPU. Report median/P95/P99, power, peak memory, and deadline-miss rates at 100/500/1000 Hz, not only average per-step time.
• Physical closed-loop control: train DT and LRAM on matched demonstrations for Franka / UR5 insertion, door opening, and dynamic obstacle avoidance. Run at least 20 seeds × 50 episodes with network jitter and occlusion, comparing success, safety stops, cumulative jerk, and recovery time.
• Fair systems stacks: give DT, Mamba, and xLSTM their best available kernels and a shared compilation policy, then compare kernel-off and kernel-on settings to separate architectural gains from software maturity.
• VLA transfer: with the same vision encoder and language model, replace only the action backbone. Compare BridgeVLA/π0-style flow heads with a shared 256-bin head on instruction generalization, action precision, TTFT, and action-chunk latency.

14.3 Emerging directions

• Online RL post-training: start from matched offline checkpoints and fine-tune DT, Mamba, and LRAM using PPO / SAC in 1024 parallel environments with equal interaction budgets. Measure throughput and policy collapse to see whether recurrent throughput becomes sample efficiency.
• Uncertainty and safe fallback: add ensembles or conformal action sets to all four backbones, triggering MPC / impedance controllers under OOD inputs. Compare risk-adjusted returns and false rejection rates.
• Long-term agent memory: compare LRAM's fixed state against explicit retrieval memory for tool-using or software agents. Measure completion, auditability, and recovery over 10k–100k steps rather than token-level loss alone.

15. Recent-work radar (verified links)

1. Emergent Dexterity via Diverse Resets and Large-Scale RL（ICLR 2026): replaces extensive task engineering with reset distributions, useful for testing whether LRAM's online RL throughput enables long-horizon dexterity; simulation gains still need safe physical validation.
2. Raw2Drive（NeurIPS 2025 session): uses privileged/raw dual world models to reduce causal confusion in end-to-end driving, testing whether fixed recurrent states suffice for world-model rollouts.
3. HMARL-CBF（NeurIPS 2025): combines multiagent high-level skills with low-level control barrier functions, supplying the formal safety layer missing from LRAM; interface latency remains open.
4. GO-Skill（ICML 2025): uses discrete skill libraries for offline multitask transfer, complementing LRAM's shared head through high-level skills versus unified low-level actions.
5. Online Pre-Training for Offline-to-Online RL（ICML 2025): introduces a new value function for online fine-tuning, directly addressing LRAM's offline-only limitation.
6. ELEMENTAL（ICML 2025): designs rewards through demonstrations and VLM interaction; combining it with LRAM could test whether language-generated rewards compensate for RTG conditioning's limited task semantics.
7. A Vision-Language-Action-Critic Model（Hugging Face Daily Paper): uses a VLA critic for dense progress rewards in real-robot RL, extending a fast action backbone toward a learned reward–action loop; critic reward hacking still needs independent auditing.
8. MUA-RL（arXiv:2508.18669): includes simulated users in multiturn tool-use RL. Both it and robotic LRAM face long-sequence credit assignment, but tool agents particularly need auditable external memory rather than opaque hidden states.

16. Final assessment

LRAM is valuable because it brings backbones, conditioning sequences, action heads, and kernels into one robotic-latency problem. Its strongest number is 206M DMControl average return moving from DT's 364.52 to xLSTM[7:1]'s 522.55(+158.03, +43.35%), while long contexts no longer expand KV caches. Its strongest counterexample is Meta-World's −1.47%, with physical robots, edge chips, and online RL all untested.

The reusable conclusion is:Modern recurrent backbones are strong candidates for long histories, parallel environments, and fixed-memory deployment. Each domain still requires a head-to-head comparison that jointly considers action conditioning, kernels, observability, and hardware. Treating xLSTM as merely a parameter-matched Transformer replacement while ignoring action removal and the shared head may fail to reproduce the reported gains.

Evidence and reproducibility notes

• Core numbers come only from ICML/PMLR, arXiv v3 PDF/HTML, and the official repository, not aggregators.
• Light/dark themes and mobile rules were statically checked. The runtime lacked a /usr/bin/chromium or /opt/pw-browsers browser binary, preventing the requested local Playwright screenshots across three viewports. The report did not run playwright install; horizontal table scrolling, responsive spacing, and high-contrast colors remain fallback measures.
• ml-report-index.md The report index was updated.