cyclo_intelligence patches: Diffusion/VQ-BeT queue-based policy fix

InferenceModelSelector.js

@@ -0,0 +1,151 @@
+// Copyright 2025 ROBOTIS CO., LTD.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+
+import React from 'react';
+import { shallowEqual, useSelector, useDispatch } from 'react-redux';
+import clsx from 'clsx';
+import {
+  markLocalTaskInfoEdited,
+  selectInferenceTaskInfo,
+  setInferenceTaskInfo,
+} from '../features/tasks/taskSlice';
+
+// Inference models. Each option pairs a backend (orchestrator routing
+// via TaskInfo.service_type) with a policy class (drives instruction
+// visibility and future per-model UI knobs). LeRobot is the backend;
+// ACT, SmolVLA, XVLA, Pi0, Pi0.5, and Diffusion are policy families that
+// can be loaded by that backend when the selected checkpoint is compatible.
+//
+// Add an enabled entry once a policy is validated end-to-end. value is the
+// composite key the dropdown stores; serviceType / policyType are the
+// fields that get written into taskInfo on selection. comingSoon entries are
+// displayed as disabled options only, so they do not affect runtime routing.
+//
+const MODEL_GROUPS = [
+  {
+    label: 'LeRobot',
+    options: [
+      { value: 'lerobot:act', label: 'ACT', serviceType: 'lerobot', policyType: 'act' },
+      { value: 'lerobot:smolvla', label: 'SmolVLA', serviceType: 'lerobot', policyType: 'smolvla' },
+      { value: 'lerobot:xvla', label: 'XVLA', serviceType: 'lerobot', policyType: 'xvla' },
+      { value: 'lerobot:pi0', label: 'Pi0', serviceType: 'lerobot', policyType: 'pi0' },
+      { value: 'lerobot:pi05', label: 'Pi0.5', serviceType: 'lerobot', policyType: 'pi05' },
+      { value: 'lerobot:diffusion', label: 'Diffusion', serviceType: 'lerobot', policyType: 'diffusion' },
+      { value: 'lerobot:vqbet', label: 'VQ-BeT', serviceType: 'lerobot', policyType: 'vqbet' }, 
+    ],
+  },
+  {
+    label: 'GR00T',
+    options: [
+      { value: 'groot:n17', label: 'N1.7', serviceType: 'groot', policyType: 'n17' },
+    ],
+  },
+  {
+    label: 'Coming Soon',
+    options: [
+      {
+        value: 'future:greenvla',
+        label: 'GreenVLA',
+        serviceType: 'future',
+        policyType: 'greenvla',
+        comingSoon: true,
+      },
+      {
+        value: 'future:openpi',
+        label: 'OpenPI',
+        serviceType: 'future',
+        policyType: 'openpi',
+        comingSoon: true,
+      },
+      {
+        value: 'future:rldx1',
+        label: 'RLDX-1',
+        serviceType: 'future',
+        policyType: 'rldx1',
+        comingSoon: true,
+      },
+    ],
+  },
+];
+
+export const MODEL_OPTIONS = MODEL_GROUPS.flatMap((group) => group.options);
+const AVAILABLE_MODEL_OPTIONS = MODEL_OPTIONS.filter((opt) => !opt.comingSoon);
+const DEFAULT = AVAILABLE_MODEL_OPTIONS[0];
+
+const classLabel = clsx(
+  'text-sm', 'text-gray-600', 'w-28', 'flex-shrink-0', 'font-medium'
+);
+
+const InferenceModelSelector = ({ readonly = false }) => {
+  const dispatch = useDispatch();
+  const info = useSelector(selectInferenceTaskInfo, shallowEqual);
+  const serviceType = info.serviceType || DEFAULT.serviceType;
+  const policyType = info.policyType || DEFAULT.policyType;
+  const value = `${serviceType}:${policyType}`;
+
+  const handleChange = (e) => {
+    const sel = AVAILABLE_MODEL_OPTIONS.find((o) => o.value === e.target.value);
+    if (!sel) return;
+    dispatch(
+      setInferenceTaskInfo({
+        serviceType: sel.serviceType,
+        policyType: sel.policyType,
+        accelerationMode: sel.serviceType === 'groot'
+          ? (info.accelerationMode || 'pytorch')
+          : 'pytorch',
+        accelerationEnginePath: sel.serviceType === 'groot'
+          ? (info.accelerationEnginePath || '')
+          : '',
+      })
+    );
+    dispatch(markLocalTaskInfoEdited({ source: 'inference' }));
+  };
+
+  return (
+    <div className={clsx('flex', 'items-center', 'mb-2.5')}>
+      <span className={classLabel}>Model</span>
+      <select
+        className={clsx(
+          'flex-1',
+          'h-8',
+          'px-2',
+          'border',
+          'border-gray-300',
+          'rounded-md',
+          'focus:outline-none',
+          'focus:ring-2',
+          'focus:ring-blue-500',
+          'focus:border-transparent',
+          {
+            'bg-gray-100 cursor-not-allowed text-gray-500': readonly,
+            'bg-white': !readonly,
+          }
+        )}
+        value={value}
+        onChange={handleChange}
+        disabled={readonly}
+      >
+        {MODEL_GROUPS.map((group) => (
+          <optgroup key={group.label} label={group.label}>
+            {group.options.map((opt) => (
+              <option
+                key={opt.value}
+                value={opt.value}
+                disabled={Boolean(opt.comingSoon)}
+              >
+                {opt.label}
+              </option>
+            ))}
+          </optgroup>
+        ))}
+      </select>
+    </div>
+  );
+};
+
+export default InferenceModelSelector;

README.md

@@ -0,0 +1,176 @@
+---
+license: apache-2.0
+tags:
+  - robotics
+  - lerobot
+  - cyclo-intelligence
+  - patch
+pretty_name: cyclo_intelligence patches (Diffusion / VQ-BeT)
+---
+
+# cyclo_intelligence 패치 — Diffusion / VQ-BeT 정책이 안 돌아가는 문제
+
+[ROBOTIS cyclo_intelligence](https://github.com/ROBOTIS-GIT/cyclo_intelligence) 에서
+**Diffusion·VQ-BeT 정책을 배포하면 로봇이 움직이지 않는다.** ACT는 정상 동작한다.
+그 원인과 수정본이다.
+
+**기준 커밋**: `8065dfc` (2026-07-10, `ROBOTIS-GIT/cyclo_intelligence` main)
+
+---
+
+## 한 줄 적용
+
+```bash
+curl -fsSL https://huggingface.co/JSHNSL/cyclo-intelligence-patches/resolve/main/apply_patches.sh | bash
+```
+
+VQ-BeT까지 쓰려면 (웹 UI 재빌드 포함):
+```bash
+curl -fsSL https://huggingface.co/JSHNSL/cyclo-intelligence-patches/resolve/main/apply_patches.sh | WITH_UI=yes bash
+```
+
+> cyclo_intelligence 가 `~/cyclo_intelligence` 가 아니면: `CYCLO_INTELLIGENCE_DIR=/경로 bash apply_patches.sh`
+> 스크립트는 **백업(`*.bak`)을 만들고**, 이미 적용됐으면 건너뛴다.
+
+---
+
+## 무엇이 문제였나
+
+### ① 엔진이 큐 기반 정책을 직접 호출한다 (핵심)
+
+`lerobot_engine/prediction.py` 는 정책 추론을 이렇게 한다:
+
+```python
+action = self._policy.predict_action_chunk(batch)      # 직접 호출
+```
+
+그런데 **Diffusion과 VQ-BeT의 `predict_action_chunk` 는 단독 호출이 불가능**하다.
+내부 observation 큐(`self._queues`)를 stack하는데, **그 큐를 채우는 건 `select_action` 뿐**이기 때문이다:
+
+```python
+# lerobot/policies/diffusion/modeling_diffusion.py
+def predict_action_chunk(self, batch, noise=None):
+    # stack n latest observations from the queue
+    batch = {k: torch.stack(list(self._queues[k]), dim=1) for k in batch if k in self._queues}
+```
+
+큐가 비어 있으니:
+```
+RuntimeError: stack expects a non-empty TensorList
+```
+→ `get_action` 실패 → **액션이 발행되지 않음 → 로봇이 안 움직인다.**
+
+**ACT는 `n_obs_steps=1` 이라 큐를 안 쓴다.** 그래서 ACT만 멀쩡했던 것이다.
+
+기존 fallback은 `except (NotImplementedError, AttributeError)` 만 잡아서 **`RuntimeError` 를 못 걸렀다.**
+
+**수정**: 큐 기반 정책은 `predict_action_chunk` 를 아예 건너뛰고 `select_action` 으로 라우팅한다.
+
+```python
+_QUEUE_BASED_POLICIES = {"VQBeTPolicy", "DiffusionPolicy"}
+
+def _predict_chunk(self, batch):
+    if type(self._policy).__name__ in self._QUEUE_BASED_POLICIES:
+        return self._select_action_chunk(batch)      # 큐를 채우는 경로
+    try:
+        ...
+    except (NotImplementedError, AttributeError, RuntimeError, AssertionError):
+        return self._select_action_chunk(batch)      # 안전망
+```
+
+### ② `diffusers` 가 추론 컨테이너에 없다
+
+Diffusion 정책이 요구한다. `lerobot_server` 컨테이너엔 **`pip` 이 없고 `uv` 를 쓴다**:
+
+```bash
+docker exec lerobot_server sh -c 'VIRTUAL_ENV=/lerobot/.venv uv pip install diffusers'
+```
+> `pip install` 은 `No module named pip` 으로 실패한다.
+
+### ③ 웹 UI 드롭다운에 VQ-BeT이 없다 (VQ-BeT만 해당)
+
+백엔드는 vqbet을 지원하는데 UI 목록에 항목이 없다. 한 줄 추가 + 재빌드가 필요하다.
+
+> ⚠️ `./docker/container.sh build-ui` 는 **실패한다.** npm을 호스트 uid로 돌리는데 UI가 컨테이너
+> `/root/` 밑이라 permission denied가 나고, 그게 **엉뚱하게 "no lockfile" 에러로 보고**된다.
+> **root로 직접 빌드**해야 한다 (스크립트가 그렇게 한다).
+
+---
+
+## 파일
+
+| 파일 | 내용 |
+|------|------|
+| `apply_patches.sh` | 전부 적용하는 스크립트 |
+| `prediction.py` | 패치된 엔진 → `cyclo_brain/policy/lerobot/lerobot_engine/prediction.py` |
+| `InferenceModelSelector.js` | VQ-BeT 항목 추가 → `orchestrator/ui/src/components/InferenceModelSelector.js` |
+| `prediction.diff` / `ui.diff` | 원본 대비 변경분 (검토용) |
+
+---
+
+## 수동 적용
+
+```bash
+CI=~/cyclo_intelligence
+BASE=https://huggingface.co/JSHNSL/cyclo-intelligence-patches/resolve/main
+
+# ① 엔진 패치
+cp "$CI/cyclo_brain/policy/lerobot/lerobot_engine/prediction.py"{,.bak}
+curl -fsSL "$BASE/prediction.py" -o "$CI/cyclo_brain/policy/lerobot/lerobot_engine/prediction.py"
+
+# ② diffusers (Diffusion 쓸 때만)
+docker exec lerobot_server sh -c 'VIRTUAL_ENV=/lerobot/.venv uv pip install diffusers'
+
+# ③ 재시작
+docker restart lerobot_server
+```
+
+VQ-BeT도 쓰려면 추가로:
+```bash
+cp "$CI/orchestrator/ui/src/components/InferenceModelSelector.js"{,.bak}
+curl -fsSL "$BASE/InferenceModelSelector.js" -o "$CI/orchestrator/ui/src/components/InferenceModelSelector.js"
+
+CID=$(docker ps -qf name=cyclo_intelligence)
+UID_D=/root/ros2_ws/src/cyclo_intelligence/orchestrator/ui
+docker exec -w "$UID_D" "$CID" bash -lc "npm ci --legacy-peer-deps"
+docker exec -w "$UID_D" "$CID" bash -lc "npm run build"
+docker exec "$CID" sh -c "cp -a $UID_D/build/. /usr/share/nginx/html/ && nginx -s reload"
+# 브라우저 강력 새로고침 (Ctrl+Shift+R)
+```
+
+---
+
+## 확인
+
+```bash
+# 엔진에 패치가 살아있나
+docker exec lerobot_server sh -c 'grep -n _QUEUE_BASED_POLICIES /app/lerobot_engine/prediction.py'
+
+# 추론 중 로그
+docker logs -f lerobot_server
+```
+- `RuntimeError: stack expects a non-empty TensorList` 가 **안 나오면** 성공
+- `Action chunk: T=..., D=...` 가 반복되면 액션이 나가는 중
+
+## 되돌리기
+
+```bash
+mv <파일>.bak <파일>
+docker restart lerobot_server
+```
+
+---
+
+## 주의
+
+- `prediction.py` 는 **호스트 파일**이고 컨테이너엔 read-only 마운트된다 → 호스트에서 고치고 **재시작**해야 반영된다.
+- `diffusers` 설치는 컨테이너의 writable layer에 들어간다. `docker restart` 는 유지되지만
+  **컨테이너를 재생성(`--force-recreate`, `docker rm`)하면 사라진다** → 다시 설치해야 한다.
+- cyclo_intelligence 가 업데이트되면 `prediction.py` 가 덮어써질 수 있다 → 그때 다시 적용한다.
+
+---
+
+## 관련
+
+- 전체 학습 파이프라인 (Isaac Sim → LeRobot → 학습 → 배포): [JSHNSL/humanoid-imitation-learning](https://huggingface.co/JSHNSL/humanoid-imitation-learning)
+- upstream: [ROBOTIS-GIT/cyclo_intelligence](https://github.com/ROBOTIS-GIT/cyclo_intelligence)

apply_patches.sh

@@ -0,0 +1,125 @@
+#!/usr/bin/env bash
+#
+# cyclo_intelligence patches — apply in one command.
+#
+#   curl -fsSL https://huggingface.co/JSHNSL/cyclo-intelligence-patches/resolve/main/apply_patches.sh | bash
+#
+# or download this file and:  bash apply_patches.sh
+#
+# What it does:
+#   1. Patches lerobot_engine/prediction.py   -> Diffusion / VQ-BeT policies actually run
+#   2. Installs `diffusers` in lerobot_server -> required by Diffusion
+#   3. (optional) Adds VQ-BeT to the web UI dropdown and rebuilds it
+#   4. Restarts lerobot_server
+#
+set -euo pipefail
+
+REPO="https://huggingface.co/JSHNSL/cyclo-intelligence-patches/resolve/main"
+CI_DIR="${CYCLO_INTELLIGENCE_DIR:-$HOME/cyclo_intelligence}"
+WITH_UI="${WITH_UI:-ask}"          # yes | no | ask
+
+say()  { printf '\n\033[1m==> %s\033[0m\n' "$*"; }
+warn() { printf '\033[33m  ! %s\033[0m\n' "$*"; }
+ok()   { printf '\033[32m  ✓ %s\033[0m\n' "$*"; }
+die()  { printf '\033[31m  ✗ %s\033[0m\n' "$*" >&2; exit 1; }
+
+# ---------------------------------------------------------------- checks
+say "Checking environment"
+[ -d "$CI_DIR" ] || die "cyclo_intelligence not found at $CI_DIR (set CYCLO_INTELLIGENCE_DIR)"
+ok "cyclo_intelligence: $CI_DIR"
+
+command -v docker >/dev/null || die "docker not found"
+docker ps --format '{{.Names}}' | grep -q '^lerobot_server$' \
+  || die "lerobot_server container is not running (start cyclo_intelligence first)"
+ok "lerobot_server is running"
+
+# ---------------------------------------------------------------- 1. engine patch
+say "1/4  Patching the inference engine (Diffusion / VQ-BeT)"
+ENGINE="$CI_DIR/cyclo_brain/policy/lerobot/lerobot_engine/prediction.py"
+[ -f "$ENGINE" ] || die "not found: $ENGINE"
+
+if grep -q '_QUEUE_BASED_POLICIES' "$ENGINE"; then
+    ok "already patched — skipping"
+else
+    cp "$ENGINE" "$ENGINE.bak"
+    ok "backup: $ENGINE.bak"
+    curl -fsSL "$REPO/prediction.py" -o "$ENGINE"
+    grep -q '_QUEUE_BASED_POLICIES' "$ENGINE" || die "download failed"
+    ok "patched prediction.py"
+fi
+
+# ---------------------------------------------------------------- 2. diffusers
+say "2/4  Installing diffusers into lerobot_server (needed by Diffusion)"
+if docker exec lerobot_server sh -c '/lerobot/.venv/bin/python -c "import diffusers"' 2>/dev/null; then
+    ok "diffusers already installed"
+else
+    # this container has uv, not pip
+    docker exec lerobot_server sh -c 'VIRTUAL_ENV=/lerobot/.venv uv pip install diffusers' >/dev/null
+    docker exec lerobot_server sh -c '/lerobot/.venv/bin/python -c "import diffusers; print(diffusers.__version__)"' \
+        | sed 's/^/  diffusers /'
+    ok "installed"
+fi
+
+# ---------------------------------------------------------------- 3. UI (VQ-BeT)
+say "3/4  Web UI — add VQ-BeT to the model dropdown"
+if [ "$WITH_UI" = "ask" ]; then
+    if [ -t 0 ]; then
+        read -r -p "  Add VQ-BeT to the dropdown? (rebuilds the UI, ~2-5 min) [y/N] " a
+        [[ "$a" =~ ^[Yy]$ ]] && WITH_UI=yes || WITH_UI=no
+    else
+        WITH_UI=no      # piped into bash: skip by default
+        warn "non-interactive — skipping UI (re-run with WITH_UI=yes to include it)"
+    fi
+fi
+
+if [ "$WITH_UI" = "yes" ]; then
+    SEL="$CI_DIR/orchestrator/ui/src/components/InferenceModelSelector.js"
+    [ -f "$SEL" ] || die "not found: $SEL"
+
+    if grep -q "lerobot:vqbet" "$SEL"; then
+        ok "dropdown already has VQ-BeT"
+    else
+        cp "$SEL" "$SEL.bak"
+        curl -fsSL "$REPO/InferenceModelSelector.js" -o "$SEL"
+        ok "patched InferenceModelSelector.js"
+    fi
+
+    CID=$(docker ps -qf name=cyclo_intelligence)
+    [ -n "$CID" ] || die "cyclo_intelligence container is not running"
+    UID_D=/root/ros2_ws/src/cyclo_intelligence/orchestrator/ui
+
+    # NOTE: ./docker/container.sh build-ui runs npm as the host uid, but the UI
+    # lives under /root/ inside the container -> permission denied, reported as a
+    # bogus "no lockfile" error. Build as root instead.
+    warn "building the UI as root (container.sh build-ui fails on permissions)"
+    docker exec -w "$UID_D" "$CID" bash -lc "npm ci --legacy-peer-deps" >/dev/null 2>&1 || true
+    docker exec -w "$UID_D" "$CID" bash -lc "npm run build" >/dev/null
+    docker exec "$CID" sh -c "cp -a $UID_D/build/. /usr/share/nginx/html/ && nginx -s reload"
+    ok "UI rebuilt — hard-refresh the browser (Ctrl+Shift+R)"
+else
+    ok "skipped (Diffusion works without it; VQ-BeT needs it)"
+fi
+
+# ---------------------------------------------------------------- 4. restart
+say "4/4  Restarting lerobot_server"
+docker restart lerobot_server >/dev/null
+for _ in $(seq 1 30); do
+    [ "$(docker inspect lerobot_server --format '{{.State.Health.Status}}' 2>/dev/null)" = healthy ] && break
+    sleep 2
+done
+ok "lerobot_server restarted"
+
+docker exec lerobot_server sh -c 'grep -c _QUEUE_BASED_POLICIES /app/lerobot_engine/prediction.py' >/dev/null \
+    && ok "engine patch is live in the container"
+
+say "Done"
+cat <<'EOF'
+  Diffusion and VQ-BeT policies will now produce actions instead of crashing with
+  "RuntimeError: stack expects a non-empty TensorList".
+
+  Watch the engine while running inference:
+      docker logs -f lerobot_server
+
+  Rollback:
+      mv <file>.bak <file>   &&   docker restart lerobot_server
+EOF

prediction.diff

@@ -0,0 +1,54 @@
+diff --git a/cyclo_brain/policy/lerobot/lerobot_engine/prediction.py b/cyclo_brain/policy/lerobot/lerobot_engine/prediction.py
+index 6e298f3..9db6547 100644
+--- a/cyclo_brain/policy/lerobot/lerobot_engine/prediction.py
++++ b/cyclo_brain/policy/lerobot/lerobot_engine/prediction.py
+@@ -21,22 +21,43 @@ logger = logging.getLogger("lerobot_engine")
+ class PredictionMixin:
+     """Policy input batch -> action chunk."""
+ 
++    # Policies whose predict_action_chunk cannot be called standalone: it
++    # stacks internal observation queues (self._queues) that ONLY select_action
++    # populates, so calling it directly raises "stack expects a non-empty
++    # TensorList" and the robot never receives an action.
++    #
++    #   DiffusionPolicy.predict_action_chunk:
++    #       batch = {k: torch.stack(list(self._queues[k]), dim=1) for k in batch ...}
++    #   VQBeTPolicy.predict_action_chunk: same, plus a combined OBS_IMAGES key
++    #       that only select_action builds.
++    #
++    # ACT does not use queues (n_obs_steps=1), which is why it works with the
++    # direct call. Route the queue-based ones through select_action instead;
++    # they manage their own action-chunk queue internally.
++    _QUEUE_BASED_POLICIES = {"VQBeTPolicy", "DiffusionPolicy"}
++
+     def _predict_chunk(self, batch: Dict[str, torch.Tensor]) -> torch.Tensor:
+         """Return a chunk tensor of shape (1, T, A)."""
+         assert self._policy is not None
++        if type(self._policy).__name__ in self._QUEUE_BASED_POLICIES:
++            return self._select_action_chunk(batch)
+         try:
+             action = self._policy.predict_action_chunk(batch)
+             if action.dim() == 2:
+                 action = action.unsqueeze(1)
+             return action
+-        except (NotImplementedError, AttributeError):
++        except (NotImplementedError, AttributeError, RuntimeError, AssertionError):
+             logger.debug(
+-                "predict_action_chunk unavailable; falling back to select_action"
++                "predict_action_chunk unavailable/failed; falling back to select_action"
+             )
+-            action = self._policy.select_action(batch)
+-            if action.dim() == 1:
+-                action = action.unsqueeze(0)
+-            return action.unsqueeze(1)
++            return self._select_action_chunk(batch)
++
++    def _select_action_chunk(self, batch: Dict[str, torch.Tensor]) -> torch.Tensor:
++        """select_action -> (1, 1, A) chunk."""
++        action = self._policy.select_action(batch)
++        if action.dim() == 1:
++            action = action.unsqueeze(0)
++        return action.unsqueeze(1)
+ 
+     @staticmethod
+     def _to_numpy_chunk(action: torch.Tensor) -> np.ndarray:

prediction.py

@@ -0,0 +1,76 @@
+#!/usr/bin/env python3
+#
+# Copyright 2026 ROBOTIS CO., LTD.
+#
+# Licensed under the Apache License, Version 2.0
+
+"""LeRobot prediction helpers."""
+
+from __future__ import annotations
+
+import logging
+from typing import Dict
+
+import numpy as np
+import torch
+
+
+logger = logging.getLogger("lerobot_engine")
+
+
+class PredictionMixin:
+    """Policy input batch -> action chunk."""
+
+    # Policies whose predict_action_chunk cannot be called standalone: it
+    # stacks internal observation queues (self._queues) that ONLY select_action
+    # populates, so calling it directly raises "stack expects a non-empty
+    # TensorList" and the robot never receives an action.
+    #
+    #   DiffusionPolicy.predict_action_chunk:
+    #       batch = {k: torch.stack(list(self._queues[k]), dim=1) for k in batch ...}
+    #   VQBeTPolicy.predict_action_chunk: same, plus a combined OBS_IMAGES key
+    #       that only select_action builds.
+    #
+    # ACT does not use queues (n_obs_steps=1), which is why it works with the
+    # direct call. Route the queue-based ones through select_action instead;
+    # they manage their own action-chunk queue internally.
+    _QUEUE_BASED_POLICIES = {"VQBeTPolicy", "DiffusionPolicy"}
+
+    def _predict_chunk(self, batch: Dict[str, torch.Tensor]) -> torch.Tensor:
+        """Return a chunk tensor of shape (1, T, A)."""
+        assert self._policy is not None
+        if type(self._policy).__name__ in self._QUEUE_BASED_POLICIES:
+            return self._select_action_chunk(batch)
+        try:
+            action = self._policy.predict_action_chunk(batch)
+            if action.dim() == 2:
+                action = action.unsqueeze(1)
+            return action
+        except (NotImplementedError, AttributeError, RuntimeError, AssertionError):
+            logger.debug(
+                "predict_action_chunk unavailable/failed; falling back to select_action"
+            )
+            return self._select_action_chunk(batch)
+
+    def _select_action_chunk(self, batch: Dict[str, torch.Tensor]) -> torch.Tensor:
+        """select_action -> (1, 1, A) chunk."""
+        action = self._policy.select_action(batch)
+        if action.dim() == 1:
+            action = action.unsqueeze(0)
+        return action.unsqueeze(1)
+
+    @staticmethod
+    def _to_numpy_chunk(action: torch.Tensor) -> np.ndarray:
+        """(B, T, A) or (B, A) tensor -> (T, A) float64 numpy."""
+        chunk = action.detach().cpu()
+        if chunk.dim() == 3:
+            chunk = chunk[0]
+        elif chunk.dim() == 2:
+            pass
+        elif chunk.dim() == 1:
+            chunk = chunk.unsqueeze(0)
+        else:
+            raise ValueError(
+                f"Unexpected action tensor shape: {tuple(chunk.shape)}"
+            )
+        return chunk.to(torch.float64).numpy()

ui.diff

@@ -0,0 +1,12 @@
+diff --git a/orchestrator/ui/src/components/InferenceModelSelector.js b/orchestrator/ui/src/components/InferenceModelSelector.js
+index bf5487d..03360fb 100644
+--- a/orchestrator/ui/src/components/InferenceModelSelector.js
++++ b/orchestrator/ui/src/components/InferenceModelSelector.js
+@@ -36,6 +36,7 @@ const MODEL_GROUPS = [
+       { value: 'lerobot:pi0', label: 'Pi0', serviceType: 'lerobot', policyType: 'pi0' },
+       { value: 'lerobot:pi05', label: 'Pi0.5', serviceType: 'lerobot', policyType: 'pi05' },
+       { value: 'lerobot:diffusion', label: 'Diffusion', serviceType: 'lerobot', policyType: 'diffusion' },
++      { value: 'lerobot:vqbet', label: 'VQ-BeT', serviceType: 'lerobot', policyType: 'vqbet' }, 
+     ],
+   },
+   {