rm65-smolvla-code / scripts /dagger_rm65_collect.py

Upload folder using huggingface_hub (part 2)

ef2a612 verified 28 days ago

15.3 kB

#!/usr/bin/env python3
"""RM65 DAgger-lite collector (Path B).
HG-DAgger clutch: hold intervene button → record expert actions; release → policy.
Mock dry-run (no robot / no VLA)::
    docker exec rm65_dev2 bash -lc 'cd /home/sdznkj/zkx_ws/sendlerobot && \\
      PYTHONPATH=. python3 scripts/dagger_rm65_collect.py \\
        --backend mock --policy mock --max_episodes 3 --steps_per_episode 12 \\
        --intervene_steps 4,5,6 --corrections_only \\
        --output_dir datasets/dagger_rm65_mock'
Real robot + SmolVLA (prefer the wrapper script)::
    scripts/rm65_run_dagger_collect.sh
"""

from __future__ import annotations

import argparse
import json
import logging
import os
import time
from pathlib import Path

import numpy as np

logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s")
logger = logging.getLogger(__name__)

ROOT = Path(__file__).resolve().parents[1]


def parse_args():
    p = argparse.ArgumentParser(description="RM65 DAgger-lite collect")
    p.add_argument("--backend", choices=["mock", "send_robot"], default="mock")
    p.add_argument("--policy", choices=["mock", "smolvla"], default="mock")
    p.add_argument(
        "--camera_set",
        default="stack",
        choices=["desk", "slot", "stack", "eval", "stack_eval", "usb", "default"],
    )
    p.add_argument("--task", type=str, default="Stack three cylinder blocks. Grasp the left cylinder.")
    p.add_argument("--max_episodes", type=int, default=3)
    p.add_argument("--steps_per_episode", type=int, default=12)
    p.add_argument("--fps", type=float, default=20.0)
    p.add_argument(
        "--corrections_only",
        action=argparse.BooleanOptionalAction,
        default=True,
        help="Only save frames/episodes that contain human corrections (default)",
    )
    p.add_argument(
        "--intervene_steps",
        type=str,
        default="4,5,6",
        help="Mock: step indices with forced hold (per episode)",
    )
    p.add_argument(
        "--safety",
        action=argparse.BooleanOptionalAction,
        default=True,
        help="Enable SafeActionGate on adapter send_action",
    )
    p.add_argument(
        "--require_deadman",
        action=argparse.BooleanOptionalAction,
        default=None,
        help="Require deadman button (default: off for mock / dagger; on only if set)",
    )
    p.add_argument("--speed_scale", type=float, default=0.3)
    p.add_argument("--max_delta_joints", type=float, default=2.0)
    p.add_argument("--max_delta_gripper", type=float, default=0.08)
    p.add_argument("--watchdog_timeout_s", type=float, default=0.25)
    p.add_argument("--output_dir", type=str, default="datasets/dagger_rm65_mock")
    p.add_argument("--seed", type=int, default=0)
    # Real robot
    p.add_argument(
        "--send_robot_dry_run",
        action=argparse.BooleanOptionalAction,
        default=True,
        help="send_robot without ROS/hardware (default True for offline tests)",
    )
    p.add_argument("--ckpt", type=str, default=str(ROOT / "astra_smolvla"))
    p.add_argument("--device", type=str, default="cuda")
    p.add_argument("--intervene_button", type=int, default=3, help="Hold to correct (default Y=3)")
    p.add_argument("--end_episode_button", type=int, default=1, help="Press to end episode (default B=1)")
    p.add_argument("--deadman_button", type=int, default=5)
    p.add_argument("--front_dev", type=int, default=0)
    p.add_argument("--astra_dev", type=int, default=2)
    p.add_argument("--rm_ip", type=str, default="192.168.73.18")
    p.add_argument("--rm_port", type=int, default=8080)
    return p.parse_args()


def _make_send_robot(args):
    import rclpy
    from lerobot.common.cameras.dummy import DummyCameraConfig
    from lerobot.common.cameras.opencv import OpenCVCameraConfig
    from sendrobot.send_robot import SendRobot
    from sendrobot.send_robot.config_send_robot import SendRobotConfig

    if not rclpy.ok():
        rclpy.init()

    cams = {
        "camera1": OpenCVCameraConfig(
            index_or_path=args.front_dev, width=640, height=480, fps=int(args.fps)
        ),
        "camera2": OpenCVCameraConfig(
            index_or_path=args.astra_dev, width=640, height=480, fps=int(args.fps)
        ),
        "camera3": DummyCameraConfig(width=256, height=256, fps=int(args.fps)),
        "empty_camera_0": DummyCameraConfig(width=640, height=480, fps=int(args.fps)),
    }
    cfg = SendRobotConfig(
        id="rm65_dagger",
        cameras=cams,
        motor_names=[
            "left_joint_1",
            "left_joint_2",
            "left_joint_3",
            "left_joint_4",
            "left_joint_5",
            "left_joint_6",
            "left_gripper",
        ],
        use_gripper=True,
        teleop=False,
        use_kalman_filter=True,
        initial_gripper_pos=float(os.environ.get("RM65_INITIAL_GRIPPER_POS", "1.0")),
    )
    robot = SendRobot(cfg)
    robot.connect()
    # Wait for first joint state from record_state_test
    deadline = time.time() + 15.0
    while time.time() < deadline:
        try:
            rclpy.spin_once(robot, timeout_sec=0.05)
        except Exception:
            pass
        obs = robot.get_observation()
        if obs and any(k.startswith("left_joint") for k in obs):
            logger.info("SendRobot joint feedback OK")
            return robot
        time.sleep(0.05)
    raise RuntimeError("SendRobot got no joint states — is record_state_test.py running?")


def _build_policy(args):
    from lerobot.common.policies.dagger_rm65.smolvla_actor import MockPolicy, SmolVLAActor

    if args.policy == "mock":
        return MockPolicy(seed=args.seed)
    return SmolVLAActor(args.ckpt, device=args.device, task=args.task)


def main() -> int:
    args = parse_args()
    from lerobot.common.policies.dagger_rm65 import (
        DAggerLiteController,
        save_episode_bundle,
        write_session_report,
    )
    from lerobot.common.policies.smolvla_rlt.robot_adapter import (
        MockRM65Adapter,
        SendRobotRM65Adapter,
    )
    from lerobot.common.policies.smolvla_rlt.safety import SafetyConfig

    # Real robot: prefer eval camera keys to match astra ckpt
    if args.backend == "send_robot" and not args.send_robot_dry_run and args.camera_set == "stack":
        args.camera_set = "eval"
        logger.info("camera_set auto → eval (camera1/camera2) for real send_robot")

    require_deadman = args.require_deadman
    if require_deadman is None:
        require_deadman = False

    intervene_steps = {int(x) for x in args.intervene_steps.split(",") if x.strip() != ""}
    safety_cfg = SafetyConfig(
        enabled=bool(args.safety) and not (args.backend == "send_robot" and not args.send_robot_dry_run),
        require_deadman=bool(require_deadman),
        max_delta_joints=args.max_delta_joints,
        max_delta_gripper=args.max_delta_gripper,
        speed_scale=args.speed_scale,
        watchdog_timeout_s=args.watchdog_timeout_s,
        action_dim=7,
    )

    teleop = None
    hw_robot = None
    if args.backend == "mock":
        robot = MockRM65Adapter(
            camera_set=args.camera_set,
            intervene_schedule=intervene_steps,
            seed=args.seed,
            safety=safety_cfg,
        )
    elif args.backend == "send_robot":
        if args.send_robot_dry_run:
            robot = SendRobotRM65Adapter(
                camera_set=args.camera_set,
                intervene_button=args.intervene_button,
                deadman_button=args.deadman_button,
                dry_run=True,
                seed=args.seed,
                safety=safety_cfg,
                require_deadman=require_deadman,
            )
        else:
            from lerobot.common.policies.dagger_rm65.gamepad_teleop import GamepadClutchTeleop

            teleop = GamepadClutchTeleop(
                intervene_button=args.intervene_button,
                end_episode_button=args.end_episode_button,
                ip=args.rm_ip,
                port=args.rm_port,
            )
            teleop.connect()
            hw_robot = _make_send_robot(args)
            robot = SendRobotRM65Adapter(
                camera_set=args.camera_set,
                intervene_button=args.intervene_button,
                deadman_button=args.deadman_button,
                dry_run=False,
                robot=hw_robot,
                human_action_provider=lambda: teleop.human_action(),
                seed=args.seed,
                safety=safety_cfg,
                require_deadman=require_deadman,
            )
            # Use gamepad clutch for intervene poll (shared stick/joystick)
            robot.intervention = teleop
            robot.deadman.backend = "mock"  # deadman off unless --require_deadman
            if require_deadman:
                robot.deadman.backend = "gamepad"
    else:
        raise SystemExit(f"unknown backend={args.backend}")

    policy = _build_policy(args)
    ctrl = DAggerLiteController(corrections_only=args.corrections_only, task=args.task)
    out_dir = Path(args.output_dir)
    out_dir.mkdir(parents=True, exist_ok=True)

    robot.connect()
    target_dt = 1.0 / args.fps
    sources_seen: set[str] = set()
    saved = 0

    logger.info(
        "DAgger start backend=%s policy=%s dry_run=%s fps=%g intervene_btn=%d",
        args.backend,
        args.policy,
        getattr(args, "send_robot_dry_run", True),
        args.fps,
        args.intervene_button,
    )
    if args.backend == "send_robot" and not args.send_robot_dry_run:
        logger.info(
            "手柄: 按住 b%d(Y) 介入纠偏 | LB/RB 开合爪 | 点 b%d(B) 结束本集 | Ctrl+C 退出",
            args.intervene_button,
            args.end_episode_button,
        )

    try:
        for ep in range(1, args.max_episodes + 1):
            logger.info("=" * 60)
            logger.info("DAgger episode %d/%d", ep, args.max_episodes)
            if hasattr(robot, "reset_episode"):
                robot.reset_episode()
            if teleop is not None:
                teleop.reset()
            if hasattr(policy, "reset"):
                policy.reset()
            ctrl.reset_episode()

            prev_holding = False
            for step in range(args.steps_per_episode):
                t0 = time.time()
                # Spin ROS so joint callbacks keep flowing
                if hw_robot is not None:
                    try:
                        import rclpy

                        rclpy.spin_once(hw_robot, timeout_sec=0.0)
                    except Exception:
                        pass

                if args.backend == "send_robot" and args.send_robot_dry_run:
                    robot.set_force_intervention(step in intervene_steps)

                obs = robot.get_observation()
                holding = robot.poll_intervention()

                # Falling edge of intervene: flush SmolVLA action queue
                if prev_holding and not holding and hasattr(policy, "reset"):
                    policy.reset()

                if holding:
                    # Keep last autonomous action for logging; don't burn GPU / queue
                    policy_action = getattr(robot, "_last_policy_action", obs.state.copy())
                else:
                    policy_action = policy.act(obs.state, obs.images)
                    robot._last_policy_action = policy_action.copy()
                prev_holding = holding

                human = None
                if holding:
                    if teleop is not None:
                        human = teleop.human_action(obs.state)
                    else:
                        human = robot.human_action()

                action, source = ctrl.on_step(
                    state=obs.state,
                    policy_action=policy_action,
                    human_action=human,
                    images=obs.images,
                    holding=holding,
                )
                sources_seen.add(source)
                robot.send_action(action)

                if step % max(1, int(args.fps)) == 0:
                    logger.info(
                        "  step %d | %s | hold=%s | J2=%.1f J3=%.1f G=%.2f",
                        step,
                        source,
                        holding,
                        float(obs.state[1]),
                        float(obs.state[2]),
                        float(obs.state[6]) if obs.state.shape[0] > 6 else -1.0,
                    )

                if teleop is not None and teleop.consume_end_episode():
                    logger.info("  early end episode at step %d", step)
                    break

                sleep = target_dt - (time.time() - t0)
                if sleep > 0:
                    time.sleep(min(sleep, 0.05))

            # If last frame was correcting→release mid-episode, reset policy queue for next ep
            if hasattr(policy, "reset"):
                policy.reset()

            finished = ctrl.end_episode()
            if finished is not None:
                path = save_episode_bundle(finished, out_dir, saved)
                saved += 1
                logger.info(
                    "  saved %s frames=%d intervention=%d",
                    path,
                    len(finished.frames),
                    finished.n_intervention,
                )
            else:
                logger.info("  episode not saved (no corrections?)")
    except KeyboardInterrupt:
        logger.info("Interrupted by user")
    finally:
        robot.disconnect()
        if teleop is not None:
            teleop.disconnect()
        if hw_robot is not None:
            try:
                hw_robot.disconnect()
            except Exception:
                pass
            try:
                import rclpy

                if rclpy.ok():
                    rclpy.shutdown()
            except Exception:
                pass

    report = write_session_report(
        out_dir,
        ctrl.completed_episodes,
        extra={
            "sources_seen": sorted(sources_seen),
            "corrections_only": args.corrections_only,
            "backend": args.backend,
            "policy": args.policy,
            "send_robot_dry_run": bool(getattr(args, "send_robot_dry_run", True)),
            "pass_has_human": "HUMAN" in sources_seen,
            "pass_saved_episodes": saved > 0,
            "pass_intervention_frames": sum(e.n_intervention for e in ctrl.completed_episodes) > 0,
        },
    )
    report["pass"] = (
        report["pass_has_human"]
        and report["pass_saved_episodes"]
        and report["pass_intervention_frames"]
    )
    (out_dir / "session_report.json").write_text(
        json.dumps(report, indent=2, ensure_ascii=False), encoding="utf-8"
    )
    print(json.dumps(report, indent=2, ensure_ascii=False))
    if report["pass"]:
        logger.info("PASS DAgger-lite collect")
        return 0
    # Real sessions may Ctrl+C before a full corrected episode — still exit 0 if any data
    if saved > 0:
        logger.warning("Partial session: saved=%d (not all pass flags)", saved)
        return 0
    logger.error("FAIL DAgger-lite collect")
    return 1


if __name__ == "__main__":
    raise SystemExit(main())

	#!/usr/bin/env python3
	"""RM65 DAgger-lite collector (Path B).

	HG-DAgger clutch: hold intervene button → record expert actions; release → policy.

	Mock dry-run (no robot / no VLA)::

	docker exec rm65_dev2 bash -lc 'cd /home/sdznkj/zkx_ws/sendlerobot && \\
	PYTHONPATH=. python3 scripts/dagger_rm65_collect.py \\
	--backend mock --policy mock --max_episodes 3 --steps_per_episode 12 \\
	--intervene_steps 4,5,6 --corrections_only \\
	--output_dir datasets/dagger_rm65_mock'

	Real robot + SmolVLA (prefer the wrapper script)::

	scripts/rm65_run_dagger_collect.sh
	"""

	from __future__ import annotations

	import argparse
	import json
	import logging
	import os
	import time
	from pathlib import Path

	import numpy as np

	logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s")
	logger = logging.getLogger(__name__)

	ROOT = Path(__file__).resolve().parents[1]


	def parse_args():
	p = argparse.ArgumentParser(description="RM65 DAgger-lite collect")
	p.add_argument("--backend", choices=["mock", "send_robot"], default="mock")
	p.add_argument("--policy", choices=["mock", "smolvla"], default="mock")
	p.add_argument(
	"--camera_set",
	default="stack",
	choices=["desk", "slot", "stack", "eval", "stack_eval", "usb", "default"],
	)
	p.add_argument("--task", type=str, default="Stack three cylinder blocks. Grasp the left cylinder.")
	p.add_argument("--max_episodes", type=int, default=3)
	p.add_argument("--steps_per_episode", type=int, default=12)
	p.add_argument("--fps", type=float, default=20.0)
	p.add_argument(
	"--corrections_only",
	action=argparse.BooleanOptionalAction,
	default=True,
	help="Only save frames/episodes that contain human corrections (default)",
	)
	p.add_argument(
	"--intervene_steps",
	type=str,
	default="4,5,6",
	help="Mock: step indices with forced hold (per episode)",
	)
	p.add_argument(
	"--safety",
	action=argparse.BooleanOptionalAction,
	default=True,
	help="Enable SafeActionGate on adapter send_action",
	)
	p.add_argument(
	"--require_deadman",
	action=argparse.BooleanOptionalAction,
	default=None,
	help="Require deadman button (default: off for mock / dagger; on only if set)",
	)
	p.add_argument("--speed_scale", type=float, default=0.3)
	p.add_argument("--max_delta_joints", type=float, default=2.0)
	p.add_argument("--max_delta_gripper", type=float, default=0.08)
	p.add_argument("--watchdog_timeout_s", type=float, default=0.25)
	p.add_argument("--output_dir", type=str, default="datasets/dagger_rm65_mock")
	p.add_argument("--seed", type=int, default=0)
	# Real robot
	p.add_argument(
	"--send_robot_dry_run",
	action=argparse.BooleanOptionalAction,
	default=True,
	help="send_robot without ROS/hardware (default True for offline tests)",
	)
	p.add_argument("--ckpt", type=str, default=str(ROOT / "astra_smolvla"))
	p.add_argument("--device", type=str, default="cuda")
	p.add_argument("--intervene_button", type=int, default=3, help="Hold to correct (default Y=3)")
	p.add_argument("--end_episode_button", type=int, default=1, help="Press to end episode (default B=1)")
	p.add_argument("--deadman_button", type=int, default=5)
	p.add_argument("--front_dev", type=int, default=0)
	p.add_argument("--astra_dev", type=int, default=2)
	p.add_argument("--rm_ip", type=str, default="192.168.73.18")
	p.add_argument("--rm_port", type=int, default=8080)
	return p.parse_args()


	def _make_send_robot(args):
	import rclpy
	from lerobot.common.cameras.dummy import DummyCameraConfig
	from lerobot.common.cameras.opencv import OpenCVCameraConfig
	from sendrobot.send_robot import SendRobot
	from sendrobot.send_robot.config_send_robot import SendRobotConfig

	if not rclpy.ok():
	rclpy.init()

	cams = {
	"camera1": OpenCVCameraConfig(
	index_or_path=args.front_dev, width=640, height=480, fps=int(args.fps)
	),
	"camera2": OpenCVCameraConfig(
	index_or_path=args.astra_dev, width=640, height=480, fps=int(args.fps)
	),
	"camera3": DummyCameraConfig(width=256, height=256, fps=int(args.fps)),
	"empty_camera_0": DummyCameraConfig(width=640, height=480, fps=int(args.fps)),
	}
	cfg = SendRobotConfig(
	id="rm65_dagger",
	cameras=cams,
	motor_names=[
	"left_joint_1",
	"left_joint_2",
	"left_joint_3",
	"left_joint_4",
	"left_joint_5",
	"left_joint_6",
	"left_gripper",
	],
	use_gripper=True,
	teleop=False,
	use_kalman_filter=True,
	initial_gripper_pos=float(os.environ.get("RM65_INITIAL_GRIPPER_POS", "1.0")),
	)
	robot = SendRobot(cfg)
	robot.connect()
	# Wait for first joint state from record_state_test
	deadline = time.time() + 15.0
	while time.time() < deadline:
	try:
	rclpy.spin_once(robot, timeout_sec=0.05)
	except Exception:
	pass
	obs = robot.get_observation()
	if obs and any(k.startswith("left_joint") for k in obs):
	logger.info("SendRobot joint feedback OK")
	return robot
	time.sleep(0.05)
	raise RuntimeError("SendRobot got no joint states — is record_state_test.py running?")


	def _build_policy(args):
	from lerobot.common.policies.dagger_rm65.smolvla_actor import MockPolicy, SmolVLAActor

	if args.policy == "mock":
	return MockPolicy(seed=args.seed)
	return SmolVLAActor(args.ckpt, device=args.device, task=args.task)


	def main() -> int:
	args = parse_args()
	from lerobot.common.policies.dagger_rm65 import (
	DAggerLiteController,
	save_episode_bundle,
	write_session_report,
	)
	from lerobot.common.policies.smolvla_rlt.robot_adapter import (
	MockRM65Adapter,
	SendRobotRM65Adapter,
	)
	from lerobot.common.policies.smolvla_rlt.safety import SafetyConfig

	# Real robot: prefer eval camera keys to match astra ckpt
	if args.backend == "send_robot" and not args.send_robot_dry_run and args.camera_set == "stack":
	args.camera_set = "eval"
	logger.info("camera_set auto → eval (camera1/camera2) for real send_robot")

	require_deadman = args.require_deadman
	if require_deadman is None:
	require_deadman = False

	intervene_steps = {int(x) for x in args.intervene_steps.split(",") if x.strip() != ""}
	safety_cfg = SafetyConfig(
	enabled=bool(args.safety) and not (args.backend == "send_robot" and not args.send_robot_dry_run),
	require_deadman=bool(require_deadman),
	max_delta_joints=args.max_delta_joints,
	max_delta_gripper=args.max_delta_gripper,
	speed_scale=args.speed_scale,
	watchdog_timeout_s=args.watchdog_timeout_s,
	action_dim=7,
	)

	teleop = None
	hw_robot = None
	if args.backend == "mock":
	robot = MockRM65Adapter(
	camera_set=args.camera_set,
	intervene_schedule=intervene_steps,
	seed=args.seed,
	safety=safety_cfg,
	)
	elif args.backend == "send_robot":
	if args.send_robot_dry_run:
	robot = SendRobotRM65Adapter(
	camera_set=args.camera_set,
	intervene_button=args.intervene_button,
	deadman_button=args.deadman_button,
	dry_run=True,
	seed=args.seed,
	safety=safety_cfg,
	require_deadman=require_deadman,
	)
	else:
	from lerobot.common.policies.dagger_rm65.gamepad_teleop import GamepadClutchTeleop

	teleop = GamepadClutchTeleop(
	intervene_button=args.intervene_button,
	end_episode_button=args.end_episode_button,
	ip=args.rm_ip,
	port=args.rm_port,
	)
	teleop.connect()
	hw_robot = _make_send_robot(args)
	robot = SendRobotRM65Adapter(
	camera_set=args.camera_set,
	intervene_button=args.intervene_button,
	deadman_button=args.deadman_button,
	dry_run=False,
	robot=hw_robot,
	human_action_provider=lambda: teleop.human_action(),
	seed=args.seed,
	safety=safety_cfg,
	require_deadman=require_deadman,
	)
	# Use gamepad clutch for intervene poll (shared stick/joystick)
	robot.intervention = teleop
	robot.deadman.backend = "mock" # deadman off unless --require_deadman
	if require_deadman:
	robot.deadman.backend = "gamepad"
	else:
	raise SystemExit(f"unknown backend={args.backend}")

	policy = _build_policy(args)
	ctrl = DAggerLiteController(corrections_only=args.corrections_only, task=args.task)
	out_dir = Path(args.output_dir)
	out_dir.mkdir(parents=True, exist_ok=True)

	robot.connect()
	target_dt = 1.0 / args.fps
	sources_seen: set[str] = set()
	saved = 0

	logger.info(
	"DAgger start backend=%s policy=%s dry_run=%s fps=%g intervene_btn=%d",
	args.backend,
	args.policy,
	getattr(args, "send_robot_dry_run", True),
	args.fps,
	args.intervene_button,
	)
	if args.backend == "send_robot" and not args.send_robot_dry_run:
	logger.info(
	"手柄: 按住 b%d(Y) 介入纠偏 \| LB/RB 开合爪 \| 点 b%d(B) 结束本集 \| Ctrl+C 退出",
	args.intervene_button,
	args.end_episode_button,
	)

	try:
	for ep in range(1, args.max_episodes + 1):
	logger.info("=" * 60)
	logger.info("DAgger episode %d/%d", ep, args.max_episodes)
	if hasattr(robot, "reset_episode"):
	robot.reset_episode()
	if teleop is not None:
	teleop.reset()
	if hasattr(policy, "reset"):
	policy.reset()
	ctrl.reset_episode()

	prev_holding = False
	for step in range(args.steps_per_episode):
	t0 = time.time()
	# Spin ROS so joint callbacks keep flowing
	if hw_robot is not None:
	try:
	import rclpy

	rclpy.spin_once(hw_robot, timeout_sec=0.0)
	except Exception:
	pass

	if args.backend == "send_robot" and args.send_robot_dry_run:
	robot.set_force_intervention(step in intervene_steps)

	obs = robot.get_observation()
	holding = robot.poll_intervention()

	# Falling edge of intervene: flush SmolVLA action queue
	if prev_holding and not holding and hasattr(policy, "reset"):
	policy.reset()

	if holding:
	# Keep last autonomous action for logging; don't burn GPU / queue
	policy_action = getattr(robot, "_last_policy_action", obs.state.copy())
	else:
	policy_action = policy.act(obs.state, obs.images)
	robot._last_policy_action = policy_action.copy()
	prev_holding = holding

	human = None
	if holding:
	if teleop is not None:
	human = teleop.human_action(obs.state)
	else:
	human = robot.human_action()

	action, source = ctrl.on_step(
	state=obs.state,
	policy_action=policy_action,
	human_action=human,
	images=obs.images,
	holding=holding,
	)
	sources_seen.add(source)
	robot.send_action(action)

	if step % max(1, int(args.fps)) == 0:
	logger.info(
	" step %d \| %s \| hold=%s \| J2=%.1f J3=%.1f G=%.2f",
	step,
	source,
	holding,
	float(obs.state[1]),
	float(obs.state[2]),
	float(obs.state[6]) if obs.state.shape[0] > 6 else -1.0,
	)

	if teleop is not None and teleop.consume_end_episode():
	logger.info(" early end episode at step %d", step)
	break

	sleep = target_dt - (time.time() - t0)
	if sleep > 0:
	time.sleep(min(sleep, 0.05))

	# If last frame was correcting→release mid-episode, reset policy queue for next ep
	if hasattr(policy, "reset"):
	policy.reset()

	finished = ctrl.end_episode()
	if finished is not None:
	path = save_episode_bundle(finished, out_dir, saved)
	saved += 1
	logger.info(
	" saved %s frames=%d intervention=%d",
	path,
	len(finished.frames),
	finished.n_intervention,
	)
	else:
	logger.info(" episode not saved (no corrections?)")
	except KeyboardInterrupt:
	logger.info("Interrupted by user")
	finally:
	robot.disconnect()
	if teleop is not None:
	teleop.disconnect()
	if hw_robot is not None:
	try:
	hw_robot.disconnect()
	except Exception:
	pass
	try:
	import rclpy

	if rclpy.ok():
	rclpy.shutdown()
	except Exception:
	pass

	report = write_session_report(
	out_dir,
	ctrl.completed_episodes,
	extra={
	"sources_seen": sorted(sources_seen),
	"corrections_only": args.corrections_only,
	"backend": args.backend,
	"policy": args.policy,
	"send_robot_dry_run": bool(getattr(args, "send_robot_dry_run", True)),
	"pass_has_human": "HUMAN" in sources_seen,
	"pass_saved_episodes": saved > 0,
	"pass_intervention_frames": sum(e.n_intervention for e in ctrl.completed_episodes) > 0,
	},
	)
	report["pass"] = (
	report["pass_has_human"]
	and report["pass_saved_episodes"]
	and report["pass_intervention_frames"]
	)
	(out_dir / "session_report.json").write_text(
	json.dumps(report, indent=2, ensure_ascii=False), encoding="utf-8"
	)
	print(json.dumps(report, indent=2, ensure_ascii=False))
	if report["pass"]:
	logger.info("PASS DAgger-lite collect")
	return 0
	# Real sessions may Ctrl+C before a full corrected episode — still exit 0 if any data
	if saved > 0:
	logger.warning("Partial session: saved=%d (not all pass flags)", saved)
	return 0
	logger.error("FAIL DAgger-lite collect")
	return 1


	if __name__ == "__main__":
	raise SystemExit(main())