diff --git a/COMMANDS.md b/COMMANDS.md
index cc56223..7963f53 100644
--- a/COMMANDS.md
+++ b/COMMANDS.md
@@ -167,6 +167,81 @@ bash tools/run/stop_cocktail_motion_preview.sh
 `run_emulator`, `DRCF M0609`, 관련 RViz까지 확인합니다. 남은 virtual/emulator가
 있으면 실제 one-click은 계속 거부됩니다.
 
+### 측정 조인트 티칭값 기반 RViz preview
+
+`calibration.yaml`의 `cup_pre_place_joints_deg`, `cup_place_joints_deg`,
+`press_pre_joints_deg`, `press_contact_joints_deg`를 읽어서 `/joint_states`만
+publish합니다. 실제 로봇 서비스, MoveJoint, MoveLine, 그리퍼 서비스는 호출하지
+않습니다.
+
+RViz까지 한 번에 띄우려면 이 wrapper를 씁니다.
+
+```bash
+source /opt/ros/humble/setup.bash
+cd /home/ssu/Azas
+source install/setup.bash
+bash tools/run/show_measured_recipe_joint_preview_rviz.sh --dispenser-ids 1 --loop
+```
+
+이 wrapper는 기본적으로 창현 side-grip 로직과 같은 source tree의
+`src/azas_bringup/config/safety.yaml`,
+`src/azas_bringup/config/measured_dispenser_collision.yaml`을 명시적으로 로드합니다.
+`side_grip_table`, `side_grip_workspace_*` 안전영역, measured dispenser collision,
+full collision YAML marker를 RViz에 띄웁니다. 깜빡임이 있으면 남은 preview 노드를
+정리하고 다시 실행합니다.
+
+```bash
+cd /home/ssu/Azas
+source /opt/ros/humble/setup.bash
+source install/setup.bash
+pkill -f 'preview_measured_dispenser_recipe_rviz.py|publish_measured_recipe_joint_rviz_preview.py|joint_state_relay.py|dispenser_sequence_preview_node|workspace_collision_scene_node|measured_dispenser_collision_scene_node|collision_scene_rviz_publisher|link6_gripper_collision_node|__node:=m0609_robot_state_publisher' || true
+pkill -x rviz2 || true
+
+DISPLAY=:20.0 \
+SHOW_WORKSPACE_SAFETY=true \
+SHOW_MEASURED_DISPENSER_COLLISION=true \
+SHOW_FULL_COLLISION_SCENE=true \
+PUBLISH_WORKSPACE_COLLISION_OBJECTS=true \
+PUBLISH_DISPENSER_COLLISION_OBJECTS=true \
+JOINT_VELOCITY_DEG_S=40.0 \
+HOLD_SECONDS=1.0 \
+PUBLISH_RATE=60.0 \
+bash tools/run/show_measured_recipe_joint_preview_rviz.sh \
+  --dispenser-ids 1 \
+  --no-press-reset-before-press \
+  --press-use-recorded-pre-joints \
+  --press-depth-m 0.040 \
+  --press-extra-depth-m 0.0 \
+  --safe-lift-joint-fallback \
+  --press-lock-contact-joints 6 \
+  --loop
+```
+
+첫 번째 터미널에서 RViz demo를 실행합니다.
+
+```bash
+source /opt/ros/humble/setup.bash
+cd /home/ssu/Azas
+source install/setup.bash
+ros2 launch dsr_moveit_config_m0609 demo.launch.py
+```
+
+다른 터미널에서 측정 조인트 preview publisher를 실행합니다. 이 Python 명령만으로는
+RViz 창을 띄우지 않습니다.
+
+```bash
+source /opt/ros/humble/setup.bash
+cd /home/ssu/Azas
+source install/setup.bash
+python3 tools/run/preview_measured_dispenser_recipe_rviz.py --dispenser-ids 1 --loop
+```
+
+예: 1번 디스펜서를 2회, 3번 디스펜서를 1회 순서로 표시
+
+```bash
+python3 tools/run/preview_measured_dispenser_recipe_rviz.py --dispenser-ids 1x2,3
+```
+
 ### 색상 스캔 자세 RViz preview
 
 디스펜서 색상 구분 전에 쓰는 카메라 보기 관절 자세
diff --git a/asdfas b/asdfas
new file mode 100644
index 0000000..5d57cf3
--- /dev/null
+++ b/asdfas
@@ -0,0 +1,129 @@
+diff --git a/tools/run/check_one_click_cocktail_config.sh b/tools/run/check_one_click_cocktail_config.sh
+index 34ac73a..e45cfba 100755
+--- a/tools/run/check_one_click_cocktail_config.sh
++++ b/tools/run/check_one_click_cocktail_config.sh
+@@ -89,6 +89,7 @@ try:
+             raise ValueError(f"dispenser_outlets.{dispenser_id} missing in {calibration_path}")
+         require_list(outlet, "press_pose_xyz_m", 3, f"dispenser_outlets.{dispenser_id}")
+         require_list(outlet, "press_pose_rpy_deg", 3, f"dispenser_outlets.{dispenser_id}")
++        require_list(outlet, "press_pre_joints_deg", 6, f"dispenser_outlets.{dispenser_id}")
+         require_list(outlet, "press_contact_joints_deg", 6, f"dispenser_outlets.{dispenser_id}")
+ 
+     grouped: list[tuple[str, int]] = []
+diff --git a/tools/run/check_one_click_cocktail_result.sh b/tools/run/check_one_click_cocktail_result.sh
+index 030d95c..51bc4a9 100755
+--- a/tools/run/check_one_click_cocktail_result.sh
++++ b/tools/run/check_one_click_cocktail_result.sh
+@@ -52,8 +52,10 @@ fi
+ for needle in \
+   'RG2 full-open release complete; continuing only after open settle wait' \
+   'RG2 close empty gripper for dispenser press' \
+-  'move to measured press contact joints exactly' \
+-  'press dispenser pump' \
++  'PRESS_PRE measured press pre-contact joints' \
++  'PRESS_CONTACT measured contact joints' \
++  'PRESS_Z_OVERDRIVE from measured contact' \
++  'return to PRESS_CONTACT after Z overdrive' \
+   'RG2 soft side-grasp' \
+   'post-grasp lift'; do
+   if grep -q "${needle}" "${INTEGRATED_LOG}"; then
+diff --git a/tools/run/run_color_recipe_sequence.py b/tools/run/run_color_recipe_sequence.py
+index 6d17c7f..62085f6 100644
+--- a/tools/run/run_color_recipe_sequence.py
++++ b/tools/run/run_color_recipe_sequence.py
+@@ -267,10 +267,10 @@ def main() -> int:
+     )
+     parser.add_argument(
+         "--press-lock-contact-joints",
+-        default="6",
++        default="",
+         help=(
+-            "measured sequence로 전달할 contact 조인트 잠금 축. 기본 6: "
+-            "호환 모드에서만 pre 자세 값으로 J6을 유지합니다. 기본 contact-only 경로에서는 사용하지 않습니다."
++            "measured sequence로 전달할 contact 조인트 잠금 축. 기본 빈 값: "
++            "측정된 PRESS_CONTACT joint를 그대로 사용합니다."
+         ),
+     )
+     parser.add_argument("--press-pre-lift-m", default="0.080")
+diff --git a/tools/run/run_measured_dispenser_recipe_sequence.py b/tools/run/run_measured_dispenser_recipe_sequence.py
+index 8753107..05e0dd7 100755
+--- a/tools/run/run_measured_dispenser_recipe_sequence.py
++++ b/tools/run/run_measured_dispenser_recipe_sequence.py
+@@ -2,8 +2,8 @@
+ """Run an ordered measured-dispenser recipe loop.
+ 
+ For each dispenser ID this composes measured rule-based primitives:
+-  move/release cup at DISP_PRE/DISP_PLACE -> measured PRESS_CONTACT FK
+-  -> generated Z-only PRESS_PRE -> measured contact -> Z-only pump stroke
++  move/release cup at DISP_PRE/DISP_PLACE -> measured PRESS_PRE/PRESS_CONTACT
++  -> Z-only pump overdrive -> measured PRESS_CONTACT -> measured PRESS_PRE
+   -> re-grasp/lift cup at DISP_PLACE.
+ 
+ All cup/dispenser positions come from measured calibration data.  This runner
+@@ -389,18 +389,26 @@ def print_dry_run_group_detail(args: argparse.Namespace, dispenser_id: str, pres
+     cup_pre = load_cup_pre_place_joints_deg(dispenser_id)
+     cup_place = load_cup_place_joints_deg(dispenser_id)
+     if cup_pre is not None and cup_place is not None:
+-        print(
+-            f"[PLAN] dispenser {dispenser_id}: cup DISP_PRE={format_joints_deg(cup_pre)} "
+-            f"-> DISP_PLACE={format_joints_deg(cup_place)}"
+-        )
++        print(f"[Azas] DISP_PRE={format_joints_deg(cup_pre)}")
++        print(f"[Azas] DISP_PLACE={format_joints_deg(cup_place)}")
++        print(f"[PLAN] dispenser {dispenser_id}: cup DISP_PRE -> DISP_PLACE -> RELEASE")
+     else:
+         print(f"[PLAN] dispenser {dispenser_id}: cup placement fallback=front_hold_poses")
+ 
+     press_contact = load_press_ready_joints_deg(dispenser_id)
++    press_pre = load_press_pre_joints_deg(dispenser_id) if press_contact is not None else None
+     z_overdrive_mm = (max(args.press_depth_m, 0.0) + max(args.press_extra_depth_m, 0.0)) * 1000.0
+-    if press_contact is not None:
++    if press_contact is not None and press_pre is not None:
++        print(f"[Azas] PRESS_PRE={format_joints_deg(press_pre)}")
++        print(f"[Azas] PRESS_CONTACT={format_joints_deg(press_contact)}")
++        print(
++            f"[PLAN] dispenser {dispenser_id}: press PRESS_PRE -> PRESS_CONTACT "
++            f"-> PRESS_Z_OVERDRIVE {z_overdrive_mm:.1f}mm -> PRESS_CONTACT -> PRESS_PRE x{press_count}"
++        )
++    elif press_contact is not None:
++        print(f"[Azas] PRESS_CONTACT={format_joints_deg(press_contact)}")
+         print(
+-            f"[PLAN] dispenser {dispenser_id}: press CONTACT={format_joints_deg(press_contact)} "
++            f"[PLAN] dispenser {dispenser_id}: press contact-only fallback CONTACT "
+             f"-> generated PRE=CONTACT+Z{max(args.press_contact_entry_lift_m, 0.0) * 1000.0:.1f}mm "
+             f"-> PRESS=CONTACT-Z{z_overdrive_mm:.1f}mm x{press_count}"
+         )
+@@ -1297,11 +1305,48 @@ class IntegratedRecipeMotion:
+             time.sleep(settle_sec)
+ 
+     def move_and_release(self, dispenser_id: str) -> None:
++        cup_pre_joints = load_cup_pre_place_joints_deg(dispenser_id)
+         cup_place_joints = load_cup_place_joints_deg(dispenser_id)
+-        if cup_place_joints is not None:
++        if cup_pre_joints is not None and cup_place_joints is not None:
++            print(f"[Azas] DISP_PRE={format_joints_deg(cup_pre_joints)}")
++            print(f"[Azas] DISP_PLACE={format_joints_deg(cup_place_joints)}")
+             print(
+                 f"[Azas] cup placement: dispenser={dispenser_id} using measured "
+-                "DISP_PLACE with generated high entry; not front_hold_poses"
++                "DISP_PRE -> DISP_PLACE joint teaching; not front_hold_poses"
++            )
++            cup_pre_joints = self.normalize_joints_near_current(
++                cup_pre_joints,
++                label=f"move to measured DISP{dispenser_id}_PRE cup-place joints",
++            )
++            self.movej(
++                cup_pre_joints,
++                label=f"DISP_PRE measured DISP{dispenser_id} cup-place approach",
++                velocity=self.args.move_prehold_velocity,
++                acceleration=self.args.move_prehold_acceleration,
++            )
++            cup_place_joints = self.normalize_joints_near_current(
++                cup_place_joints,
++                label=f"move to measured DISP{dispenser_id}_PLACE cup-place joints",
++            )
++            self.movej(
++                cup_place_joints,
++                label=f"DISP_PLACE measured DISP{dispenser_id} cup release",
++                velocity=self.args.move_velocity,
++                accelera
\ No newline at end of file
diff --git a/docs/robot_pipeline_control.html b/docs/robot_pipeline_control.html
index a43f1b3..003b3e4 100644
--- a/docs/robot_pipeline_control.html
+++ b/docs/robot_pipeline_control.html
@@ -841,31 +841,23 @@ <h1>Azas Robot Pipeline Control</h1>
       </div>
 
       <div class="quick-row operator-actions" aria-label="quick real cocktail controls">
-        <div class="quick-note">실험 순서: <b>연결 준비</b> → <b>1 창현 side-grip</b> → 성공 확인 후 <b>2 소명 누운 컵</b> → 성공 확인 후 <b>3 강개발자 뚜껑</b>. 로직 버튼은 한 번에 묶지 말고 단독 실행합니다.</div>
+        <div class="quick-note">현재 후보 순서: <b>tmux 연결 준비</b> → <b>수빈 STT/주문 UI</b> → <b>색상 스캔</b> → <b>창현 side-grip</b> / <b>소명 누운컵(현재 점검 필요)</b> → <b>통합 디스펜서</b> → <b>강모 ArUco 뚜껑 체결</b> → <b>쉐이킹</b>.</div>
         <label class="direct-dispenser-field">DIRECT / 레시피 override
-          <input id="recipeDispenserIds" type="text" value="" placeholder="비우면 latest_recipe.json + 색상맵 사용 / 색상 예: red1,blue3 / 진단용 번호 예: 1x2,3x2">
+          <input id="recipeDispenserIds" type="text" value="" placeholder="색상:횟수 예: red:2,blue:2,green:2,yellow:2 / 번호 예: 1x2,3x2">
         </label>
         <div class="operator-button-grid module-grid">
           <button id="startPrepBtn" class="quick-start-btn" title="검증된 tmux 방식으로 azas-logic 세션에 로봇, RG2 그리퍼, RealSense, joint relay를 분리 시작">1. tmux 연결 준비<br><small>로봇·그리퍼·카메라</small></button>
-          <button id="connectRobotBtn" type="button" title="검증된 tmux 연결 스택을 시작">tmux 준비<br><small>로봇 포함</small></button>
-          <button id="connectGripperBtn" type="button" title="검증된 tmux 연결 스택을 시작">tmux 준비<br><small>그리퍼 포함</small></button>
-          <button id="connectCameraBtn" type="button" title="검증된 tmux 연결 스택을 시작. RealSense는 640x480x30 저부하 프로파일로 시작">tmux 준비<br><small>카메라 포함</small></button>
-          <button id="cameraViewBtn" type="button" title="rqt_image_view로 /camera/camera/color/image_raw 화면 창을 띄움">카메라 화면</button>
-          <button id="yoloDetectBtn" type="button" title="YOLO 인식 토픽 시작. 화면 창은 띄우지 않음">YOLO 인식</button>
-          <button id="sideGripBtn" class="quick-start-btn" title="1단계: PR #20 / dsr_practice yolo_cup_pick_node. tmux 창에서 RealSense 컵 화면 확인 후 p 키로 side-grip 실행">1. 창현 side-grip<br><small>카메라 확인→p로 집기</small></button>
-          <button id="cupUprightingBtn" class="quick-start-btn" title="2단계: 소명씨 azas_cup_uprighting. OpenCV 창에서 누운 컵 확인 후 p 키로 직립화 실행, Esc/q로 종료">2. 소명 누운 컵<br><small>창 확인→p 실행</small></button>
-          <button id="pickLidBtn" class="quick-start-btn" title="develop 뚜껑 grip pose 계획: 빨간 스티커/YOLO/depth 기반 pose 후보 발행. 실제 모션 아님">뚜껑 grip pose 계획<br><small>빨간스티커→pose 후보</small></button>
-          <button id="lidGripCloseBtn" class="quick-start-btn" title="3단계: 강개발자 lid_grip_close. 뚜껑 보기 자세 이동 → ArUco DICT_6X6_250 id0 뚜껑 pose 인식 → RG2 파지 → 컵 위치 이동 → J6 twist로 뚜껑 닫기">3. 뚜껑 잡고 닫기<br><small>강개발자 · ArUco→grip→J6</small></button>
+          <button id="sttRecipeBtn" class="quick-start-btn" title="수빈 STT/주문 UI 후보: azas_voice voice screen을 띄우고 /azas/voice/confirmed_recipe_decision을 기다려 latest_recipe.json 저장">수빈 STT / 주문 UI<br><small>말하기→응→레시피</small></button>
           <button id="colorScanJsonBtn" class="quick-start-btn" title="이미 tmux 연결/RealSense가 켜진 상태에서 color_scan_pose로 이동한 뒤 visible color handle을 바로 검출하고 JSON/debug 이미지를 저장">2. 빠른 색상구분<br><small>포즈이동→핸들검출→JSON</small></button>
           <button id="colorJsonCheckBtn" type="button" title="outputs/dispenser_color_map.json 또는 failed 상태 확인">JSON 확인</button>
           <button id="manualColorJsonBtn" type="button" title="색상 맵을 직접 확정해 outputs/dispenser_color_map.json 저장">JSON 수동저장</button>
+          <button id="sideGripBtn" class="quick-start-btn" title="PR #20 / dsr_practice yolo_cup_pick_node. 컵 잡기 성공 메시지 후 통합 디스펜서 레시피 자동 실행">1. 창현 side-grip<br><small>성공 후 자동레시피</small></button>
+          <button id="cupUprightingBtn" class="quick-start-btn" title="2단계: 소명씨 azas_cup_uprighting. 현재 yolo_cup_uprighting_node.py 문법 오류로 점검 필요">2. 소명 누운 컵<br><small>현재 점검 필요</small></button>
           <button id="recipeCycleBtn" class="quick-start-btn" title="latest_recipe.json과 dispenser_color_map.json을 읽어 컵놓기→프레스→다시잡기 사이클을 레시피대로 반복">3. 레시피 디스펜서 사이클<br><small>컵놓기→프레스→다시잡기 반복</small></button>
+          <button id="pickLidBtn" class="quick-start-btn" title="develop 뚜껑 grip pose 계획: 빨간 스티커/YOLO/depth 기반 pose 후보 발행. 실제 모션 아님">뚜껑 grip pose 계획<br><small>빨간스티커→pose 후보</small></button>
+          <button id="lidGripCloseBtn" class="quick-start-btn" title="디스펜서 이동/프레스 성공 후 시험: 강개발자 lid_grip_close. 뚜껑 보기 자세 이동 → ArUco pose 인식 → RG2 파지 → 컵 위치 이동 → J6 twist로 뚜껑 닫기 → 성공 status 후 컵홀더 재픽업/쉐이킹 자동 진행">ArUco 뚜껑 체결 시험<br><small>성공 후 재픽업→쉐이킹</small></button>
           <button id="cupHolderBtn" type="button" title="MoveItPy로 cup_holder.side_grip_place pre_place→place_final→retreat 경로를 계획/실행">4. 컵홀더에 컵 옮기기<br><small>MoveIt 경로계획</small></button>
-          <button id="fullCocktailRealBtn" class="quick-start-btn" title="준비, 색상 JSON, 레시피 디스펜서 사이클, 컵홀더 배치를 한 번에 큐에 추가">전체 묶기<br><small>준비→색상JSON→레시피사이클→컵홀더</small></button>
-        </div>
-        <div class="secondary-actions">
-          <button id="oneClickReadyBtn" class="plain-btn" title="현재 real/virtual 세션과 Doosan/RG2 서비스 상태를 확인">준비확인 추가</button>
-          <button id="oneClickResultBtn" class="plain-btn" title="최근 one-click 실제 실행 로그에서 컵놓기→프레스→다시잡기 성공 증거를 판정">결과확인 추가</button>
+          <button id="fullCocktailRealBtn" class="quick-start-btn" title="창현/소명 side-grip 선택이 아직 확정되지 않아 전체 묶기는 실행하지 않음">전체 묶기 보류<br><small>창현/소명 선택 대기</small></button>
         </div>
       </div>
 
@@ -891,7 +883,10 @@ <h1>Azas Robot Pipeline Control</h1>
             <input id="dispenserTcpName" type="text" value="GripperDA_v1_jarvis" placeholder="Doosan controller TCP 이름">
           </label>
           <label class="field">CUP_HOLDER_PLACE_FINAL_Z_OFFSET_M
-            <input id="cupHolderPlaceFinalZOffsetM" type="text" value="-0.020" placeholder="예: -0.020 (홀더에 놓을 때 최종 Z 20mm 낮춤)">
+            <input id="cupHolderPlaceFinalZOffsetM" type="text" value="-0.030" placeholder="예: -0.030 (홀더에 놓을 때 최종 Z 30mm 낮춤)">
+          </label>
+          <label class="field">CUP_HOLDER_PLACE_FINAL_Y_OFFSET_M
+            <input id="cupHolderPlaceFinalYOffsetM" type="text" value="-0.010" placeholder="예: -0.010 (홀더 최종 Y -10mm)">
           </label>
           <label class="field">CUP_HOLDER_PICK_Z_OFFSET_M
             <input id="cupHolderPickZOffsetM" type="text" value="-0.020" placeholder="예: -0.020 (쉐이킹 전 잡기 Z 20mm 낮춤)">
@@ -976,6 +971,10 @@ <h1>Azas Robot Pipeline Control</h1>
   --moveit-planning-attempts 5 \
   --moveit-velocity-scaling 0.08 \
   --moveit-acceleration-scaling 0.06 \
+  --approach-velocity 80.0 \
+  --place-velocity 80.0 \
+  --retreat-velocity 80.0 \
+  --place-final-y-offset-m -0.010 \
   --place-final-z-offset-m -0.020 \
   --execute --confirm ENABLE_CUP_HOLDER_PLACE</code></pre>
         </div>
@@ -1057,7 +1056,7 @@ <h2>디버그 단계</h2>
     </aside>
     </div>
 
-      <section class="camera-panel" aria-label="camera preview">
+      <section class="camera-panel" aria-label="camera preview" hidden>
         <div class="camera-head">
           <div>
             <h2>RealSense 카메라 화면</h2>
@@ -1072,7 +1071,7 @@ <h2>RealSense 카메라 화면</h2>
           </div>
         </div>
         <div class="camera-frame">
-          <img id="cameraPreview" alt="RealSense color preview" src="/api/camera_snapshot.jpg?init=1">
+          <img id="cameraPreview" alt="RealSense color preview" src="data:image/gif;base64,R0lGODlhAQABAAAAACw=">
         </div>
         <pre id="colorScanResult" class="camera-result">색상 스캔 결과 대기</pre>
       </section>
@@ -1097,6 +1096,7 @@ <h2>RealSense 카메라 화면</h2>
     const core = new Set(["connect_robot", "status_check", "start_collision_scene", "stop_azas_all"]);
     const hiddenStepKeys = new Set([
       "rviz_color_scan_pose_preview",
+      "rviz_cocktail_collision_preview",
       "shake_rviz_preview",
       "stop_cocktail_motion_preview",
       "check_one_click_cocktail_ready",
@@ -1104,8 +1104,6 @@ <h2>RealSense 카메라 화면</h2>
       "run_cocktail_now_real",
       "start_camera_view",
       "detect_cup_lid",
-      "voice_input",
-      "listen_stt_recipe",
       "run_one_click_cocktail_real",
       "move_to_dispenser_1",
       "move_to_dispenser_2",
@@ -1120,9 +1118,10 @@ <h2>RealSense 카메라 화면</h2>
       "pick_from_dispenser_3",
       "pick_from_dispenser_4",
     ]);
-    const groupOrder = ["core", "grip", "move", "press", "shake", "blocked", "etc"];
+    const groupOrder = ["core", "voice", "grip", "move", "press", "shake", "blocked", "etc"];
     const groupLabels = {
       core: "연결/준비",
+      voice: "수빈 STT/주문 UI",
       grip: "그리퍼",
       move: "컵 이동/배치",
       press: "통합 디스펜서 (컵놓기→프레스→다시잡기)",
@@ -1176,6 +1175,7 @@ <h2>RealSense 카메라 화면</h2>
     function stepGroup(step) {
       const key = step.key || "";
       if (core.has(key)) return "core";
+      if (key.includes("voice") || key.includes("stt")) return "voice";
       if (key === "start_camera" || key === "detect_cup_lid" || key.includes("color_scan")) return "camera";
       if (key.includes("gripper")) return "grip";
       if (key.startsWith("teach_front_hold_")) return "teach";
@@ -1214,6 +1214,7 @@ <h2>RealSense 카메라 화면</h2>
         dispenser_tcp_name: document.getElementById("dispenserTcpName").value.trim(),
         recipe_dispenser_ids: document.getElementById("recipeDispenserIds")?.value.trim() || "",
         cup_holder_place_final_z_offset_m: document.getElementById("cupHolderPlaceFinalZOffsetM").value.trim(),
+        cup_holder_place_final_y_offset_m: document.getElementById("cupHolderPlaceFinalYOffsetM").value.trim(),
         cup_holder_pick_z_offset_m: document.getElementById("cupHolderPickZOffsetM").value.trim(),
         armed: document.getElementById("armed").checked,
         selected: selectedStepKeys()
@@ -1304,36 +1305,7 @@ <h2>RealSense 카메라 화면</h2>
     }
 
     function withCollisionScenePrereq(queue) {
-      const items = queue.map((item) => ({...item}));
-      function ensureBefore(targetKey, prereqKeys) {
-        let targetIndex = items.findIndex((item) => item.key === targetKey);
-        if (targetIndex < 0) return;
-        for (const prereq of prereqKeys) {
-          const existingIndex = items.findIndex((item) => item.key === prereq);
-          if (existingIndex >= 0) {
-            if (existingIndex < targetIndex) continue;
-            items.splice(existingIndex, 1);
-            if (existingIndex < targetIndex) targetIndex -= 1;
-          }
-        }
-        targetIndex = items.findIndex((item) => item.key === targetKey);
-        const missing = prereqKeys.filter((prereq) => !items.slice(0, targetIndex).some((item) => item.key === prereq));
-        missing.forEach((prereq, offset) => {
-          items.splice(targetIndex + offset, 0, {id: `q${nextQueueId++}`, key: prereq, injected: true});
-        });
-      }
-      // 창현/소명/강개발자 단독 테스트는 이미 열린 tmux/ROS 세션을 재사용한다.
-      // 전체 준비 묶음은 각 통합 플로우 버튼에서 명시적으로 넣는다.
-      ensureBefore("color_scan", ["connect_robot", "status_check", "move_to_color_scan_pose", "start_camera"]);
-      const firstCollisionIndex = items.findIndex((item) => needsCollisionScene(item.key));
-      if (firstCollisionIndex < 0) return items;
-      const existingSceneIndex = items.findIndex((item) => item.key === "start_collision_scene");
-      if (existingSceneIndex >= 0 && existingSceneIndex <= firstCollisionIndex) return items;
-      const withoutScene = items.filter((item) => item.key !== "start_collision_scene");
-      const insertIndex = withoutScene.findIndex((item) => needsCollisionScene(item.key));
-      if (insertIndex < 0) return withoutScene;
-      withoutScene.splice(insertIndex, 0, {id: `q${nextQueueId++}`, key: "start_collision_scene", injected: true});
-      return withoutScene;
+      return queue.map((item) => ({...item}));
     }
 
 	    function renderSummary() {
@@ -1848,7 +1820,7 @@ <h2>RealSense 카메라 화면</h2>
       const res = await fetch("/api/dispenser_color_map");
       const data = await res.json();
       if (data.fallback || !data.map) {
-        throw new Error(`색상맵이 없습니다. 먼저 색상 스캔을 성공시키거나, 진단용 물리 디스펜서 번호(예: 1x1,2x1)를 직접 입력하세요.\n${data.fallback_reason || ""}`);
+        throw new Error(`색상맵이 없습니다. 먼저 색상 스캔을 성공시키거나, 직접 입력하세요. 색상 예: red:2,blue:2 / 번호 예: 1x1,2x1\n${data.fallback_reason || ""}`);
       }
       const order = String(data.sequence_compact || data.sequence_csv || "1x1,2x1,3x1,4x1").trim();
       input.value = order;
@@ -1934,9 +1906,6 @@ <h2>RealSense 카메라 화면</h2>
       }
     }
 
-    document.getElementById("oneClickReadyBtn")?.addEventListener("click", () => {
-      queueOnly(["check_one_click_cocktail_ready"], "준비확인을 큐에 추가했습니다.");
-    });
     const PREP_STEPS = ["start_tmux_stack"];
     function queuePrepBundle(message) {
       queueOnly(PREP_STEPS, message || "검증된 tmux 연결 스택 시작을 큐에 추가했습니다. status_check/개별 연결 큐를 반복하지 않습니다.");
@@ -1944,32 +1913,20 @@ <h2>RealSense 카메라 화면</h2>
     document.getElementById("startPrepBtn")?.addEventListener("click", () => {
       queuePrepBundle();
     });
-    document.getElementById("connectRobotBtn")?.addEventListener("click", () => {
-      queuePrepBundle("tmux 연결 스택 시작을 큐에 추가했습니다. 로봇/그리퍼/카메라를 azas-logic 세션에 분리 실행합니다.");
-    });
-    document.getElementById("connectGripperBtn")?.addEventListener("click", () => {
-      queuePrepBundle("tmux 연결 스택 시작을 큐에 추가했습니다. 그리퍼도 같은 azas-logic 세션에서 시작합니다.");
-    });
-    document.getElementById("connectCameraBtn")?.addEventListener("click", () => {
-      queuePrepBundle("tmux 연결 스택 시작을 큐에 추가했습니다. RealSense는 검증된 640x480x30 설정으로 시작합니다.");
-    });
-    document.getElementById("cameraViewBtn")?.addEventListener("click", () => {
-      queueOnly(["start_camera_view"], "rqt_image_view 카메라 화면 보기를 큐에 추가했습니다.");
-    });
-    document.getElementById("yoloDetectBtn")?.addEventListener("click", () => {
-      queueOnly(["detect_cup_lid"], "YOLO 컵/뚜껑 인식 토픽 시작을 큐에 추가했습니다. 이 스텝은 화면 창을 띄우지 않습니다.");
+    document.getElementById("sttRecipeBtn")?.addEventListener("click", () => {
+      queueOnly(["voice_input", "listen_stt_recipe"], "수빈 STT/주문 UI 후보를 큐에 추가했습니다. voice screen에서 메뉴를 말하거나 입력한 뒤 '응'으로 확정하면 latest_recipe.json을 저장합니다.");
     });
     document.getElementById("cupUprightingBtn")?.addEventListener("click", () => {
-      queueOnly(["cup_uprighting"], "2단계 소명/누운 컵 직립화 로직만 단독으로 큐에 추가했습니다. 1단계 성공 확인 후 실행하세요. OpenCV 창에서 컵을 확인한 뒤 p 키로 실행합니다.");
+      queueOnly(["cup_uprighting"], "소명/누운 컵 직립화 후보를 큐에 추가했습니다. 현재 yolo_cup_uprighting_node.py 문법 오류가 있어 수정 전에는 실행 실패합니다.");
     });
     document.getElementById("sideGripBtn")?.addEventListener("click", () => {
-      queueOnly(["side_grip"], "1단계 창현/PR #20 RealSense side-grip만 단독으로 큐에 추가했습니다. 카메라 화면에서 컵을 확인한 뒤 p 키로 직접 잡습니다. 실패하거나 로봇이 안 움직이면 이 단계만 다시 실행하세요.");
+      queueOnly(["side_grip"], "창현/PR #20 RealSense side-grip을 큐에 추가했습니다. OpenCV 창에서 p 키로 컵 잡기가 성공하면 통합 디스펜서 레시피가 자동 실행됩니다.");
     });
     document.getElementById("pickLidBtn")?.addEventListener("click", () => {
       queueOnly(["start_camera", "pick_lid"], "뚜껑 grip pose 계획 로직을 큐에 추가했습니다. 실제 로봇 모션은 실행하지 않습니다.");
     });
     document.getElementById("lidGripCloseBtn")?.addEventListener("click", () => {
-      queueOnly(["lid_grip_close"], "3단계 강개발자 lid_grip_close만 단독으로 큐에 추가했습니다. 1/2단계 성공 확인 후 실행하세요. ArUco 확인 후 p 키 흐름으로 실행합니다.");
+      queueOnly(["lid_grip_close"], "ArUco 뚜껑 체결 시험을 큐에 추가했습니다. 뚜껑 보기 자세 이동 뒤 ArUco 확인/p 키로 성공하면 컵홀더 컵 재픽업→쉐이킹으로 바로 이어집니다.");
     });
 
     document.getElementById("colorScanJsonBtn")?.addEventListener("click", () => {
@@ -1989,19 +1946,16 @@ <h2>RealSense 카메라 화면</h2>
       queueOnly(["place_cup_holder"], "컵홀더 배치를 큐에 추가했습니다. 이 단계는 MoveItPy 경로계획으로 pre_place→place_final→RG2 open→retreat를 실행합니다.");
     });
     document.getElementById("fullCocktailRealBtn")?.addEventListener("click", async () => {
-      queueOnly([...PREP_STEPS, "side_grip_camera_home", "side_grip", "move_to_color_scan_pose", "color_scan", "run_color_recipe_sequence", "place_cup_holder"], "전체 플로우를 큐에 추가했습니다. (tmux 연결 준비 → 카메라 홈→컵 side-grip → 검증자세 색상 핸들 JSON → 레시피 사이클 → MoveIt 컵홀더 배치)", {clear: true});
-    });
-    document.getElementById("oneClickResultBtn")?.addEventListener("click", () => {
-      queueOnly(["check_one_click_cocktail_result"], "결과확인을 큐에 추가했습니다.");
+      log.textContent = "현재 후보 흐름은 tmux 연결 준비 → 수빈 STT/주문 UI → 색상 스캔 → 창현 side-grip 또는 소명 누운컵 → 통합 디스펜서 → 강모 ArUco 뚜껑 체결 → 쉐이킹입니다. 단, 소명 누운컵은 현재 문법 오류로 점검 필요합니다.";
+      focusLog();
     });
-
 	    document.getElementById("run").addEventListener("click", async () => {
 	      if (isRunning) {
 	        log.textContent = "이미 실행 중입니다. 준비 중인 로봇/그리퍼/카메라 단계가 끝날 때까지 다음 실행을 막습니다.";
 	        focusLog();
 	        return;
 	      }
-	      const selected = withCollisionScenePrereq(selectedQueue);
+	      const selected = selectedQueue.map((item) => ({...item}));
 	      selectedQueue = selected;
 	      resetResultBadges();
 	      isRunning = Boolean(selected.length);
@@ -2129,9 +2083,7 @@ <h2>RealSense 카메라 화면</h2>
       textarea.remove();
     });
 
-    refreshCameraPreview();
     refreshColorScanResult();
-    setInterval(refreshCameraPreview, 2000);
     loadSteps().catch((err) => { log.textContent = String(err); focusLog(); });
   </script>
 </body>
diff --git a/models/mediapipe/hand_landmarker.task b/models/mediapipe/hand_landmarker.task
new file mode 100644
index 0000000..0d53faf
Binary files /dev/null and b/models/mediapipe/hand_landmarker.task differ
diff --git a/omx_wiki/index.md b/omx_wiki/index.md
index 831b414..345ce9a 100644
--- a/omx_wiki/index.md
+++ b/omx_wiki/index.md
@@ -1,10 +1,6 @@
 # Wiki Index
 
-> 6 pages | Last updated: 2026-06-10T16:48:48+09:00
-
-## operation-rules
-
-- [Robot Operation Rules](robot-operation-rules.md) — Real robot motion checks must not be replaced by dry-run commands; D1-D4 press contacts are saved and confirmed.
+> 8 pages | Last updated: 2026-06-11T23:23:12.255Z
 
 ## session-log
 
@@ -13,3 +9,6 @@
 - [Session Log 2026-05-28](session-log-2026-05-28-3-adlm15.md) — # Session Log 2026-05-28
 - [Session Log 2026-06-05](session-log-2026-06-05-8-3rrp4t.md) — # Session Log 2026-06-05
 - [Session Log 2026-06-07](session-log-2026-06-07-9-5l0d8p.md) — # Session Log 2026-06-07
+- [Session Log 2026-06-10](session-log-2026-06-10-7-prx6mu.md) — # Session Log 2026-06-10
+- [Session Log 2026-06-11](session-log-2026-06-11-5-rp8btb.md) — # Session Log 2026-06-11
+- [Session Log 2026-06-11](session-log-2026-06-11-6-dnt3rj.md) — # Session Log 2026-06-11
diff --git a/omx_wiki/log.md b/omx_wiki/log.md
index 92f6d0f..97ffc6a 100644
--- a/omx_wiki/log.md
+++ b/omx_wiki/log.md
@@ -73,3 +73,15 @@
 ## [2026-06-07T11:46:17.707Z] session-end
 - **Pages:** session-log-2026-06-07-9-5l0d8p.md
 - **Summary:** Auto-captured session log for omx-1780832772689-5l0d8p
+## [2026-06-10T10:52:52.607Z] session-end
+- **Pages:** session-log-2026-06-10-7-prx6mu.md
+- **Summary:** Auto-captured session log for omx-1780826697197-prx6mu
+
+## [2026-06-11T13:16:04.802Z] session-end
+- **Pages:** session-log-2026-06-11-5-rp8btb.md
+- **Summary:** Auto-captured session log for omx-1781173835835-rp8btb
+
+## [2026-06-11T23:23:12.252Z] session-end
+- **Pages:** session-log-2026-06-11-6-dnt3rj.md
+- **Summary:** Auto-captured session log for omx-1781218680276-dnt3rj
+
diff --git a/omx_wiki/robot-operation-rules.md b/omx_wiki/robot-operation-rules.md
index ac926ea..08b8e13 100644
--- a/omx_wiki/robot-operation-rules.md
+++ b/omx_wiki/robot-operation-rules.md
@@ -30,3 +30,24 @@ Confirmed state:
 - D4 press-only real-motion check also works normally. The earlier observed `MoveLine returned success=false` was caused by a cable disconnect, not by the saved D4 contact. D4 status is `press_contact_status: measured_confirmed`.
 
 Do not resurrect the stale `PRESS1_CONTACT invalid_reteach_required` note unless the operator newly invalidates the saved D1 contact.
+
+## 2026-06-10 Dispenser Cup Place Mapping
+
+Operator-confirmed correction:
+
+- Previous DISP2 cup place/re-grasp pose was actually the physical DISP4 cup position.
+- Previous DISP3 cup place/re-grasp pose was actually the physical DISP2 cup position.
+- Physical DISP3 cup place/re-grasp pose still needs re-teaching.
+
+Current intended calibration state:
+
+- D1 cup place: measured confirmed.
+- D2 cup place: uses the previous D3 measured cup place values.
+- D3 cup place: re-taught and measured confirmed at 2026-06-10T18:41-18:42+09:00.
+- D4 cup place: uses the previous D2 measured cup place values.
+
+Re-grasp path correction:
+
+- Do not lower to measured `DISP_PRE` before the cup re-grasp intermediate point.
+- After press, use `HOME joint -> high rear-entry -> lowered rear-entry -> final cup grasp`.
+- For cup placement/re-grasp offset, `--move-release-offset-x-m -0.030` is 10 mm closer to the dispenser than `-0.040`.
diff --git a/omx_wiki/session-log-2026-06-10-7-prx6mu.md b/omx_wiki/session-log-2026-06-10-7-prx6mu.md
new file mode 100644
index 0000000..bd6e116
--- /dev/null
+++ b/omx_wiki/session-log-2026-06-10-7-prx6mu.md
@@ -0,0 +1,18 @@
+---
+title: "Session Log 2026-06-10"
+tags: ["session-log", "auto-captured"]
+created: 2026-06-10T10:52:52.607Z
+updated: 2026-06-10T10:52:52.607Z
+sources: ["omx-1780826697197-prx6mu"]
+links: []
+category: session-log
+confidence: medium
+schemaVersion: 1
+---
+
+# Session Log 2026-06-10
+
+Auto-captured session metadata.
+Session ID: omx-1780826697197-prx6mu
+
+Review and promote significant findings to curated wiki pages via `wiki_ingest`.
diff --git a/omx_wiki/session-log-2026-06-11-5-rp8btb.md b/omx_wiki/session-log-2026-06-11-5-rp8btb.md
new file mode 100644
index 0000000..7aa8dc4
--- /dev/null
+++ b/omx_wiki/session-log-2026-06-11-5-rp8btb.md
@@ -0,0 +1,18 @@
+---
+title: "Session Log 2026-06-11"
+tags: ["session-log", "auto-captured"]
+created: 2026-06-11T13:16:04.802Z
+updated: 2026-06-11T13:16:04.802Z
+sources: ["omx-1781173835835-rp8btb"]
+links: []
+category: session-log
+confidence: medium
+schemaVersion: 1
+---
+
+# Session Log 2026-06-11
+
+Auto-captured session metadata.
+Session ID: omx-1781173835835-rp8btb
+
+Review and promote significant findings to curated wiki pages via `wiki_ingest`.
diff --git a/omx_wiki/session-log-2026-06-11-6-dnt3rj.md b/omx_wiki/session-log-2026-06-11-6-dnt3rj.md
new file mode 100644
index 0000000..93b14cb
--- /dev/null
+++ b/omx_wiki/session-log-2026-06-11-6-dnt3rj.md
@@ -0,0 +1,18 @@
+---
+title: "Session Log 2026-06-11"
+tags: ["session-log", "auto-captured"]
+created: 2026-06-11T23:23:12.252Z
+updated: 2026-06-11T23:23:12.252Z
+sources: ["omx-1781218680276-dnt3rj"]
+links: []
+category: session-log
+confidence: medium
+schemaVersion: 1
+---
+
+# Session Log 2026-06-11
+
+Auto-captured session metadata.
+Session ID: omx-1781218680276-dnt3rj
+
+Review and promote significant findings to curated wiki pages via `wiki_ingest`.
diff --git a/src/azas_bringup/config/calibration.yaml b/src/azas_bringup/config/calibration.yaml
index 765c420..198e065 100644
--- a/src/azas_bringup/config/calibration.yaml
+++ b/src/azas_bringup/config/calibration.yaml
@@ -58,77 +58,82 @@ table:
 # measured teaching/calibration data in base_link; never from STT, LLM, or VLA.
 dispenser_outlets:
   "1":
-    cup_pre_place_joints_deg: [11.63, 45.37, 110.46, 194.52, 63.57, -100.48]  # operator measured, 2026-06-10
-    cup_place_joints_deg: [10.24, 48.98, 99.43, 194.25, 55.74, -100.48]  # operator measured, 2026-06-10
+    cup_pre_place_joints_deg: [12.87, 45.19, 120.01, 195.36, 75.59, -93.10]  # operator measured, 2026-06-10
+    cup_place_joints_deg: [10.25, 46.48, 101.91, 13.06, -55.73, 84.67]  # operator measured, 2026-06-11
     outlet_pose_xyz_m: [0.555, -0.100, 0.093]  # measured cup placement pose
     outlet_pose_quaternion_xyzw: [0.019717, 0.648068, 0.033158, 0.760605]
     outlet_pose_rpy_rad: [0.429694, 1.394728, 0.448776]
     outlet_pose_rpy_deg: [24.620, 79.912, 25.713]
-    press_pose_xyz_m: [0.897411, 0.077654, 0.384322]
+    cup_place_status: measured_confirmed  # operator measured, 2026-06-11
+    press_pose_xyz_m: [0.909159, 0.075173, 0.420149]
     press_pose_quaternion_xyzw: [-0.060, 0.878, -0.024, 0.474]
-    press_pose_rpy_rad: [3.041566, -1.889330, -2.756159]
-    press_pose_rpy_deg: [174.269, -108.251, -157.916]
+    press_pose_rpy_rad: [0.057995, 1.618397, 0.535828]
+    press_pose_rpy_deg: [3.323, 92.727, 30.701]
     press_joint_state:
       name: [joint_1, joint_2, joint_4, joint_5, joint_3, joint_6]
       position_rad: [0.08982130140066147, 0.9058733582496643, 0.008466404862701893, 1.3044253587722778, 0.033748552203178406, 1.6839158535003662]
     press_pre_joints_deg: [-4.52, 25.97, 74.19, 146.71, 10.73, -141.99]  # operator measured, 2026-06-10
-    press_contact_joints_deg: [10.80, 30.88, 57.88, -38.19, 25.14, 32.93]  # operator measured, 2026-06-10
-    press_contact_status: measured_confirmed  # operator measured, 2026-06-10
+    press_contact_joints_deg: [5.22, 29.22, 69.35, 14.20, -6.03, -13.14]  # operator measured, 2026-06-11
+    press_contact_status: measured_confirmed  # operator measured, 2026-06-11
     clearance_m: null
+    press_common_pre_joints_deg: [-2.87, -12.60, 71.14, 8.30, 55.57, -4.25]  # operator measured, 2026-06-11
   "2":
-    cup_pre_place_joints_deg: [-11.43, 45.17, 110.50, 165.41, 64.36, -85.88]  # operator measured, 2026-06-10
-    cup_place_joints_deg: [-9.99, 48.08, 99.33, 165.41, 56.24, -85.88]  # operator measured, 2026-06-10
-    outlet_pose_xyz_m: [0.549, -0.150, 0.097]
-    outlet_pose_quaternion_xyzw: [-0.021772, 0.650220, 0.060986, 0.756981]
-    outlet_pose_rpy_rad: [0.293265, 1.409774, 0.410750]
-    outlet_pose_rpy_deg: [16.803, 80.774, 23.534]
-    press_pose_xyz_m: [0.894031, 0.023056, 0.383725]
+    cup_pre_place_joints_deg: [5.70, 43.85, 122.71, 189.65, 76.38, -93.10]  # operator measured, 2026-06-10
+    cup_place_joints_deg: [3.43, 46.02, 103.63, 5.85, -57.67, 84.67]  # operator measured, 2026-06-11
+    outlet_pose_xyz_m: [0.527, -0.204, 0.107]
+    outlet_pose_quaternion_xyzw: [-0.018792, 0.647687, 0.057548, 0.759498]
+    outlet_pose_rpy_rad: [0.279465, 1.403250, 0.387859]
+    outlet_pose_rpy_deg: [16.012, 80.400, 22.223]
+    cup_place_status: measured_confirmed  # operator measured, 2026-06-11
+    press_pose_xyz_m: [0.899597, 0.022643, 0.423377]
     press_pose_quaternion_xyzw: [-0.043, 0.878, -0.058, 0.473]
-    press_pose_rpy_rad: [0.006618, 1.749985, 0.448575]
-    press_pose_rpy_deg: [0.379, 100.267, 25.701]
+    press_pose_rpy_rad: [0.004332, 1.635329, 0.536580]
+    press_pose_rpy_deg: [0.248, 93.697, 30.744]
     press_joint_state:
       name: [joint_1, joint_2, joint_4, joint_5, joint_3, joint_6]
       position_rad: [-0.000876683508977294, 0.9131112098693848, 0.0780220702290535, 1.3043646812438965, 0.032502077519893646, 1.621778964996338]
     press_pre_joints_deg: [5.72, 27.39, 65.56, 167.98, -4.74, -161.56]  # operator measured, 2026-06-10
-    press_contact_joints_deg: [1.90, 27.14, 71.09, -27.11, 2.29, 23.18]  # operator measured, 2026-06-10
+    press_contact_joints_deg: [1.82, 27.25, 70.94, 14.20, -4.63, -13.14]  # operator measured, 2026-06-11
     clearance_m: null
-    press_contact_status: measured_confirmed  # operator measured, 2026-06-10
+    press_contact_status: measured_confirmed  # operator measured, 2026-06-11
   "3":
-    cup_pre_place_joints_deg: [-3.09, 44.18, 111.56, 176.17, 62.61, -89.23]  # operator measured, 2026-06-10
-    cup_place_joints_deg: [1.45, 47.74, 101.87, 177.95, 57.30, -93.60]  # operator measured, 2026-06-10
-    outlet_pose_xyz_m: [0.527, -0.204, 0.107]
-    outlet_pose_quaternion_xyzw: [-0.018792, 0.647687, 0.057548, 0.759498]
-    outlet_pose_rpy_rad: [0.279465, 1.403250, 0.387859]
-    outlet_pose_rpy_deg: [16.012, 80.400, 22.223]
-    press_pose_xyz_m: [0.891400, -0.036832, 0.384805]
+    cup_pre_place_joints_deg: [-4.55, 42.44, 117.82, 177.61, 67.77, -89.19]  # operator measured, 2026-06-10
+    cup_place_joints_deg: [-0.76, 47.06, 102.71, 4.00, -57.65, 84.67]  # operator measured, 2026-06-11
+    outlet_pose_xyz_m: null
+    outlet_pose_quaternion_xyzw: null
+    outlet_pose_rpy_rad: null
+    outlet_pose_rpy_deg: null
+    cup_place_status: measured_confirmed  # operator measured, 2026-06-11
+    press_pose_xyz_m: [0.903240, -0.033608, 0.422720]
     press_pose_quaternion_xyzw: [-0.015, 0.881, -0.075, 0.468]
-    press_pose_rpy_rad: [3.094037, -1.706159, -2.671403]
-    press_pose_rpy_deg: [177.275, -97.756, -153.060]
+    press_pose_rpy_rad: [3.083555, -1.633446, -2.605057]
+    press_pose_rpy_deg: [176.675, -93.590, -149.259]
     press_joint_state:
       name: [joint_1, joint_2, joint_4, joint_5, joint_3, joint_6]
       position_rad: [-0.08701040595769882, 0.9135012626647949, 0.13757061958312988, 1.3107753992080688, 0.032613810151815414, 1.5555728673934937]
     press_pre_joints_deg: [-4.25, 28.22, 75.41, 146.71, 10.23, -141.99]  # operator measured, 2026-06-10
-    press_contact_joints_deg: [-2.47, 26.81, 73.79, -3.80, -2.85, 0.91]  # operator measured, 2026-06-10
+    press_contact_joints_deg: [-1.76, 27.85, 70.23, 14.20, -4.63, -13.14]  # operator measured, 2026-06-11
     clearance_m: null
-    press_contact_status: measured_confirmed  # operator measured, 2026-06-10
+    press_contact_status: measured_confirmed  # operator measured, 2026-06-11
   "4":
-    cup_pre_place_joints_deg: [5.72, 27.39, 65.56, 167.98, -4.74, -161.56]  # operator measured, 2026-06-10
-    cup_place_joints_deg: [5.62, 28.54, 70.28, 167.98, -1.51, -161.56]  # operator measured, 2026-06-10
-    outlet_pose_xyz_m: [0.517, -0.235, 0.109]
-    outlet_pose_quaternion_xyzw: [-0.022035, 0.648114, 0.059471, 0.758898]
-    outlet_pose_rpy_rad: [0.268008, 1.405233, 0.383736]
-    outlet_pose_rpy_deg: [15.356, 80.514, 21.986]
-    press_pose_xyz_m: [0.888378, -0.093249, 0.383091]
+    cup_pre_place_joints_deg: [-11.43, 45.17, 110.50, 165.41, 64.36, -85.88]  # mapped from previous DISP2; operator confirmed physical DISP4, 2026-06-10
+    cup_place_joints_deg: [-7.60, 47.24, 101.73, -5.63, -57.63, 92.82]  # operator measured, 2026-06-11
+    outlet_pose_xyz_m: [0.549, -0.150, 0.097]
+    outlet_pose_quaternion_xyzw: [-0.021772, 0.650220, 0.060986, 0.756981]
+    outlet_pose_rpy_rad: [0.293265, 1.409774, 0.410750]
+    outlet_pose_rpy_deg: [16.803, 80.774, 23.534]
+    cup_place_status: measured_confirmed  # operator measured, 2026-06-11
+    press_pose_xyz_m: [0.894757, -0.090838, 0.424022]
     press_pose_quaternion_xyzw: [0.020, 0.883, -0.078, 0.462]
-    press_pose_rpy_rad: [3.022369, -1.752927, -2.672407]
-    press_pose_rpy_deg: [173.169, -100.435, -153.118]
+    press_pose_rpy_rad: [3.019592, -1.634845, -2.604996]
+    press_pose_rpy_deg: [173.010, -93.670, -149.255]
     press_joint_state:
       name: [joint_1, joint_2, joint_4, joint_5, joint_3, joint_6]
       position_rad: [-0.1493324339389801, 0.9293974041938782, 0.1349058598279953, 1.3465725183486938, -0.016838623210787773, 1.4902210235595703]
     press_pre_joints_deg: [-6.60, 26.79, 73.27, -40.78, -1.97, 38.55]  # operator measured, 2026-06-10
-    press_contact_joints_deg: [-5.77, 27.00, 71.23, -15.17, 2.29, 12.34]  # operator measured, 2026-06-10
+    press_contact_joints_deg: [-5.42, 27.16, 71.00, 14.20, -4.63, -13.14]  # operator measured, 2026-06-11
     clearance_m: null
-    press_contact_status: measured_confirmed  # operator confirmed, 2026-06-10; check failure was cable disconnect
+    press_contact_status: measured_confirmed  # operator measured, 2026-06-11
 
 cup_holder:
   parent_frame: base_link
diff --git a/src/azas_bringup/launch/auto_cup_flow_router.launch.py b/src/azas_bringup/launch/auto_cup_flow_router.launch.py
index a2cf835..e06d1d4 100644
--- a/src/azas_bringup/launch/auto_cup_flow_router.launch.py
+++ b/src/azas_bringup/launch/auto_cup_flow_router.launch.py
@@ -23,6 +23,12 @@ def generate_launch_description():
         DeclareLaunchArgument("show_classification_window", default_value="true"),
         DeclareLaunchArgument("side_extra_args", default_value=""),
         DeclareLaunchArgument("cup_uprighting_extra_args", default_value=""),
+        DeclareLaunchArgument("side_target_x_offset_m", default_value="-0.02"),
+        DeclareLaunchArgument("color_scan_at_start", default_value="true"),
+        DeclareLaunchArgument("recipe_after_success", default_value="true"),
+        DeclareLaunchArgument("recipe_colors", default_value=""),
+        DeclareLaunchArgument("cup_holder_place_z_offset_m", default_value="-0.04"),
+        DeclareLaunchArgument("lid_shake_after_recipe", default_value="true"),
         Node(
             package="azas_task_manager",
             executable="auto_cup_flow_router",
@@ -45,6 +51,12 @@ def generate_launch_description():
                 "show_classification_window": ParameterValue(LaunchConfiguration("show_classification_window"), value_type=bool),
                 "side_extra_args": LaunchConfiguration("side_extra_args"),
                 "cup_uprighting_extra_args": LaunchConfiguration("cup_uprighting_extra_args"),
+                "side_target_x_offset_m": ParameterValue(LaunchConfiguration("side_target_x_offset_m"), value_type=float),
+                "color_scan_at_start": ParameterValue(LaunchConfiguration("color_scan_at_start"), value_type=bool),
+                "recipe_after_success": ParameterValue(LaunchConfiguration("recipe_after_success"), value_type=bool),
+                "recipe_colors": LaunchConfiguration("recipe_colors"),
+                "cup_holder_place_z_offset_m": ParameterValue(LaunchConfiguration("cup_holder_place_z_offset_m"), value_type=float),
+                "lid_shake_after_recipe": ParameterValue(LaunchConfiguration("lid_shake_after_recipe"), value_type=bool),
             }],
         ),
     ])
diff --git a/src/azas_bringup/launch/measured_joint_preview_display.launch.py b/src/azas_bringup/launch/measured_joint_preview_display.launch.py
new file mode 100644
index 0000000..8437f56
--- /dev/null
+++ b/src/azas_bringup/launch/measured_joint_preview_display.launch.py
@@ -0,0 +1,174 @@
+from launch import LaunchDescription
+from launch.actions import DeclareLaunchArgument
+from launch.conditions import IfCondition
+from launch.substitutions import Command, FindExecutable, LaunchConfiguration, PathJoinSubstitution
+from launch_ros.actions import Node
+from launch_ros.parameter_descriptions import ParameterValue
+from launch_ros.substitutions import FindPackageShare
+
+
+def generate_launch_description():
+    frame_id = LaunchConfiguration("frame_id")
+    robot_color = LaunchConfiguration("robot_color")
+    use_rviz = LaunchConfiguration("use_rviz")
+    rviz_config = LaunchConfiguration("rviz_config")
+    show_workspace_safety = LaunchConfiguration("show_workspace_safety")
+    show_measured_dispenser_collision = LaunchConfiguration("show_measured_dispenser_collision")
+    show_full_collision_scene = LaunchConfiguration("show_full_collision_scene")
+    show_link6_gripper = LaunchConfiguration("show_link6_gripper")
+    publish_workspace_collision_objects = LaunchConfiguration("publish_workspace_collision_objects")
+    publish_dispenser_collision_objects = LaunchConfiguration("publish_dispenser_collision_objects")
+    safety_config_path = LaunchConfiguration("safety_config_path")
+    dispenser_collision_config_path = LaunchConfiguration("dispenser_collision_config_path")
+    calibration_path = LaunchConfiguration("calibration_path")
+
+    robot_description = {
+        "robot_description": ParameterValue(
+            Command(
+                [
+                    FindExecutable(name="xacro"),
+                    " ",
+                    PathJoinSubstitution(
+                        [FindPackageShare("dsr_description2"), "xacro", "m0609.urdf.xacro"]
+                    ),
+                    " color:=",
+                    robot_color,
+                    " simple:=true",
+                ]
+            ),
+            value_type=str,
+        )
+    }
+
+    return LaunchDescription(
+        [
+            DeclareLaunchArgument("frame_id", default_value="base_link"),
+            DeclareLaunchArgument("robot_color", default_value="white"),
+            DeclareLaunchArgument("use_rviz", default_value="false"),
+            DeclareLaunchArgument("show_workspace_safety", default_value="true"),
+            DeclareLaunchArgument("show_measured_dispenser_collision", default_value="true"),
+            DeclareLaunchArgument("show_full_collision_scene", default_value="true"),
+            DeclareLaunchArgument("show_link6_gripper", default_value="true"),
+            DeclareLaunchArgument("publish_workspace_collision_objects", default_value="true"),
+            DeclareLaunchArgument("publish_dispenser_collision_objects", default_value="true"),
+            DeclareLaunchArgument(
+                "safety_config_path",
+                default_value=PathJoinSubstitution(
+                    [FindPackageShare("azas_bringup"), "config", "safety.yaml"]
+                ),
+            ),
+            DeclareLaunchArgument(
+                "dispenser_collision_config_path",
+                default_value=PathJoinSubstitution(
+                    [
+                        FindPackageShare("azas_bringup"),
+                        "config",
+                        "measured_dispenser_collision.yaml",
+                    ]
+                ),
+            ),
+            DeclareLaunchArgument(
+                "calibration_path",
+                default_value=PathJoinSubstitution(
+                    [FindPackageShare("azas_bringup"), "config", "calibration.yaml"]
+                ),
+            ),
+            DeclareLaunchArgument(
+                "rviz_config",
+                default_value=PathJoinSubstitution(
+                    [FindPackageShare("azas_bringup"), "rviz", "azas_dispenser_sequence_clean.rviz"]
+                ),
+            ),
+            Node(
+                package="robot_state_publisher",
+                executable="robot_state_publisher",
+                name="m0609_robot_state_publisher",
+                output="screen",
+                parameters=[robot_description],
+            ),
+            Node(
+                package="azas_motion",
+                executable="workspace_collision_scene_node",
+                name="workspace_collision_scene_node",
+                output="screen",
+                condition=IfCondition(show_workspace_safety),
+                parameters=[
+                    {
+                        "safety_config_path": ParameterValue(safety_config_path, value_type=str),
+                        "publish_collision_objects": ParameterValue(
+                            publish_workspace_collision_objects,
+                            value_type=bool,
+                        ),
+                        "publish_period_sec": 2.0,
+                        "frame_id": frame_id,
+                        "table_collision_enabled": True,
+                        "table_collision_expand_to_workspace_walls": True,
+                        "workspace_boundary_collision_enabled": True,
+                    }
+                ],
+            ),
+            Node(
+                package="azas_motion",
+                executable="measured_dispenser_collision_scene_node",
+                name="measured_dispenser_collision_scene_node",
+                output="screen",
+                condition=IfCondition(show_measured_dispenser_collision),
+                parameters=[
+                    {
+                        "config_path": ParameterValue(
+                            dispenser_collision_config_path, value_type=str
+                        ),
+                        "calibration_path": ParameterValue(calibration_path, value_type=str),
+                        "publish_collision_objects": ParameterValue(
+                            publish_dispenser_collision_objects,
+                            value_type=bool,
+                        ),
+                        "publish_markers": True,
+                        "publish_rviz_visual_tools_compat": False,
+                        "publish_debug_labels": True,
+                        "publish_period_sec": 2.0,
+                    }
+                ],
+            ),
+            Node(
+                package="azas_bringup",
+                executable="collision_scene_rviz_publisher",
+                name="collision_scene_rviz_publisher",
+                output="screen",
+                condition=IfCondition(show_full_collision_scene),
+                parameters=[
+                    {
+                        "frame_id": frame_id,
+                        "safety_config_path": ParameterValue(safety_config_path, value_type=str),
+                        "dispenser_collision_config_path": ParameterValue(
+                            dispenser_collision_config_path, value_type=str
+                        ),
+                        "calibration_path": ParameterValue(calibration_path, value_type=str),
+                    }
+                ],
+            ),
+            Node(
+                package="azas_motion",
+                executable="link6_gripper_collision_node",
+                name="link6_gripper_collision_node",
+                output="screen",
+                condition=IfCondition(show_link6_gripper),
+                parameters=[
+                    {
+                        "attached_link_name": "link_6",
+                        "publish_markers": True,
+                        "marker_topic": "/azas/link6_gripper/markers",
+                        "remove_on_shutdown": False,
+                    }
+                ],
+            ),
+            Node(
+                package="rviz2",
+                executable="rviz2",
+                name="rviz2",
+                arguments=["-d", rviz_config],
+                condition=IfCondition(use_rviz),
+                output="screen",
+            ),
+        ]
+    )
diff --git a/src/azas_bringup/launch/rg2_link6_tcp.launch.py b/src/azas_bringup/launch/rg2_link6_tcp.launch.py
index c562bc0..a268add 100644
--- a/src/azas_bringup/launch/rg2_link6_tcp.launch.py
+++ b/src/azas_bringup/launch/rg2_link6_tcp.launch.py
@@ -29,7 +29,7 @@ def generate_launch_description():
         [
             DeclareLaunchArgument("open_tcp_offset_m", default_value="0.15"),
             DeclareLaunchArgument("closed_tcp_offset_m", default_value="0.25"),
-            DeclareLaunchArgument("publish_gripper_collision", default_value="true"),
+            DeclareLaunchArgument("publish_gripper_collision", default_value="false"),
             Node(
                 package="robot_state_publisher",
                 executable="robot_state_publisher",
diff --git a/src/azas_bringup/rviz/azas_dispenser_sequence_clean.rviz b/src/azas_bringup/rviz/azas_dispenser_sequence_clean.rviz
index 6a59f87..063ca22 100644
--- a/src/azas_bringup/rviz/azas_dispenser_sequence_clean.rviz
+++ b/src/azas_bringup/rviz/azas_dispenser_sequence_clean.rviz
@@ -67,6 +67,16 @@ Visualization Manager:
         Value: /visualization_marker_array
       Name: Collision Scene Default Topic
       Value: true
+    - Class: rviz_default_plugins/MarkerArray
+      Enabled: true
+      Marker Topic:
+        Depth: 5
+        Durability Policy: Volatile
+        History Policy: Keep Last
+        Reliability Policy: Reliable
+        Value: /azas/measured_joint_preview/markers
+      Name: Measured Joint Preview Steps
+      Value: true
     - Class: rviz_default_plugins/MarkerArray
       Enabled: false
       Marker Topic:
diff --git a/src/azas_cup_uprighting/azas_cup_uprighting/_base_node.py b/src/azas_cup_uprighting/azas_cup_uprighting/_base_node.py
index 336fae6..fe23838 100644
--- a/src/azas_cup_uprighting/azas_cup_uprighting/_base_node.py
+++ b/src/azas_cup_uprighting/azas_cup_uprighting/_base_node.py
@@ -31,7 +31,6 @@
 from scipy.spatial.transform import Rotation
 
 from sensor_msgs.msg import CameraInfo, Image
-from cv_bridge import CvBridge
 
 from moveit.core.robot_state import RobotState
 from moveit.planning import MoveItPy, PlanRequestParameters
@@ -67,7 +66,6 @@ def __init__(self):
         log = self.get_logger()
 
         # ── 카메라 상태 ──
-        self.bridge = CvBridge()
         self.color_image = None
         self.depth_image = None
         self.intrinsics  = None
@@ -166,10 +164,63 @@ def _cam_info_cb(self, msg):
         }
 
     def _color_cb(self, msg):
-        self.color_image = self.bridge.imgmsg_to_cv2(msg, desired_encoding="bgr8")
+        self.color_image = self._imgmsg_to_bgr(msg)
 
     def _depth_cb(self, msg):
-        self.depth_image = self.bridge.imgmsg_to_cv2(msg, desired_encoding="passthrough")
+        self.depth_image = self._imgmsg_to_array(msg)
+
+    # cv_bridge는 NumPy 1.x ABI로 빌드되어 ~/.local의 NumPy 2.x와 충돌
+    # (_ARRAY_API not found → segfault)하므로 직접 변환한다.
+    @staticmethod
+    def _imgmsg_to_array(msg: Image) -> np.ndarray:
+        encoding = msg.encoding.lower()
+        dtype_by_encoding = {
+            "8uc1": np.uint8,
+            "mono8": np.uint8,
+            "8uc3": np.uint8,
+            "rgb8": np.uint8,
+            "bgr8": np.uint8,
+            "16uc1": np.uint16,
+            "mono16": np.uint16,
+            "32fc1": np.float32,
+        }
+        channels_by_encoding = {
+            "8uc1": 1,
+            "mono8": 1,
+            "8uc3": 3,
+            "rgb8": 3,
+            "bgr8": 3,
+            "16uc1": 1,
+            "mono16": 1,
+            "32fc1": 1,
+        }
+        if encoding not in dtype_by_encoding:
+            raise ValueError(f"unsupported image encoding: {msg.encoding}")
+
+        dtype = dtype_by_encoding[encoding]
+        channels = channels_by_encoding[encoding]
+        itemsize = np.dtype(dtype).itemsize
+        row_values = msg.step // itemsize
+        data = np.frombuffer(msg.data, dtype=dtype)
+        if msg.is_bigendian != (data.dtype.byteorder == ">"):
+            data = data.byteswap().view(data.dtype.newbyteorder())
+        if channels == 1:
+            image = data.reshape((msg.height, row_values))[:, : msg.width]
+        else:
+            image = data.reshape((msg.height, row_values // channels, channels))[:, : msg.width, :]
+        return np.ascontiguousarray(image)
+
+    @classmethod
+    def _imgmsg_to_bgr(cls, msg: Image) -> np.ndarray:
+        image = cls._imgmsg_to_array(msg)
+        encoding = msg.encoding.lower()
+        if encoding in {"bgr8", "8uc3"}:
+            return image
+        if encoding == "rgb8":
+            return cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
+        if encoding in {"mono8", "8uc1"}:
+            return cv2.cvtColor(image, cv2.COLOR_GRAY2BGR)
+        raise ValueError(f"unsupported color encoding: {msg.encoding}")
 
     # ════════════════════════════════════════════
     #  Perception 래퍼
diff --git a/src/azas_description/launch/view_m0609_rg2_parametric.launch.py b/src/azas_description/launch/view_m0609_rg2_parametric.launch.py
index 6726106..3382337 100644
--- a/src/azas_description/launch/view_m0609_rg2_parametric.launch.py
+++ b/src/azas_description/launch/view_m0609_rg2_parametric.launch.py
@@ -32,7 +32,7 @@ def generate_launch_description():
         [
             DeclareLaunchArgument(
                 "rg2_mount_rpy",
-                default_value="1.570796327 0 1.570796327",
+                default_value="0 0 0",
             ),
             Node(
                 package="robot_state_publisher",
diff --git a/src/azas_description/urdf/m0609_rg2_parametric.urdf.xacro b/src/azas_description/urdf/m0609_rg2_parametric.urdf.xacro
index c46ed5a..56eaf1e 100644
--- a/src/azas_description/urdf/m0609_rg2_parametric.urdf.xacro
+++ b/src/azas_description/urdf/m0609_rg2_parametric.urdf.xacro
@@ -1,9 +1,9 @@
 <?xml version="1.0"?>
 <robot xmlns:xacro="http://www.ros.org/wiki/xacro" name="m0609_rg2_parametric">
-  <xacro:arg name="rg2_parent_link" default="tool0"/>
+  <xacro:arg name="rg2_parent_link" default="link_6"/>
   <xacro:arg name="rg2_prefix" default="rg2_"/>
   <xacro:arg name="rg2_mount_xyz" default="0 0 0"/>
-  <xacro:arg name="rg2_mount_rpy" default="3.141592654 -1.570796327 0"/>
+  <xacro:arg name="rg2_mount_rpy" default="0 0 0"/>
   <xacro:arg name="rg2_finger_joints_fixed" default="true"/>
   <xacro:arg name="rg2_tcp_link_name" default="gripper_tcp"/>
   <xacro:arg name="rg2_tcp_z_offset" default="0.213"/>
diff --git a/src/azas_perception/azas_perception/lid_marker.py b/src/azas_perception/azas_perception/lid_marker.py
index aefcf69..792dfec 100644
--- a/src/azas_perception/azas_perception/lid_marker.py
+++ b/src/azas_perception/azas_perception/lid_marker.py
@@ -254,10 +254,12 @@ def _aruco_detection_images(gray: np.ndarray) -> list[tuple[np.ndarray, float]]:
     # Upscaling materially helps when the marker body is only a few tens of
     # pixels wide in the RealSense overview frame.
     for source in (gray, equalized, sharpened):
-        variants.append((
-            cv2.resize(source, None, fx=2.0, fy=2.0, interpolation=cv2.INTER_CUBIC),
-            2.0,
-        ))
+        variants.append(
+            (
+                cv2.resize(source, None, fx=2.0, fy=2.0, interpolation=cv2.INTER_CUBIC),
+                2.0,
+            )
+        )
     return variants
 
 
diff --git a/src/azas_task_manager/azas_task_manager/auto_cup_flow_router.py b/src/azas_task_manager/azas_task_manager/auto_cup_flow_router.py
index 302fef2..025dffb 100644
--- a/src/azas_task_manager/azas_task_manager/auto_cup_flow_router.py
+++ b/src/azas_task_manager/azas_task_manager/auto_cup_flow_router.py
@@ -2,6 +2,7 @@
 
 import os
 import re
+import shlex
 import signal
 import subprocess
 import sys
@@ -72,12 +73,45 @@ def __init__(self) -> None:
         self.declare_parameter("controller_action_name", "/dsr_moveit_controller/follow_joint_trajectory")
         self.declare_parameter("side_extra_args", "")
         self.declare_parameter("cup_uprighting_extra_args", "")
+        # 사이드 그립에서 base x가 +20mm 정도 어긋나는 실측 보정값
+        self.declare_parameter("side_target_x_offset_m", -0.02)
+
+        self.declare_parameter("color_scan_at_start", True)
+        self.declare_parameter(
+            "color_scan_command",
+            "bash /home/ssu/Azas/tools/run/run_color_scan_stage.sh",
+        )
+        self.declare_parameter("recipe_after_success", True)
+        self.declare_parameter(
+            "recipe_command",
+            "cd /home/ssu/Azas && source /opt/ros/humble/setup.bash && "
+            "mkdir -p /tmp/azas_ros_logs && export ROS_LOG_DIR=/tmp/azas_ros_logs && "
+            "export ROS_DOMAIN_ID=${ROS_DOMAIN_ID:-9} && "
+            "export ROS_LOCALHOST_ONLY=${ROS_LOCALHOST_ONLY:-0} && "
+            "export FASTDDS_BUILTIN_TRANSPORTS=${FASTDDS_BUILTIN_TRANSPORTS:-UDPv4} && "
+            "if [ -f /home/ssu/ws_moveit/install/setup.bash ]; then source /home/ssu/ws_moveit/install/setup.bash; fi && "
+            "if [ -f /home/ssu/ros2_ws/install/setup.bash ]; then source /home/ssu/ros2_ws/install/setup.bash; fi && "
+            "if [ -f /home/ssu/Azas/install/setup.bash ]; then source /home/ssu/Azas/install/setup.bash; "
+            "else source /home/ssu/Azas/install/local_setup.bash; fi && "
+            "export PYTHONPATH=/home/ssu/Azas/tools/run/python_compat:${PYTHONPATH:-} && "
+            "python3 tools/run/run_color_recipe_sequence.py --execute --confirm",
+        )
+        # 키오스크/음성 주문(latest_recipe.json) 없이 색을 직접 내릴 때: 예) "red:2,blue:1"
+        self.declare_parameter("recipe_colors", "")
+        # 디스펜서 누르기 종료 후 컵홀더에 놓을 때 z를 더 낮추는 실측 보정값
+        self.declare_parameter("cup_holder_place_z_offset_m", -0.04)
+        self.declare_parameter("lid_shake_after_recipe", True)
+        self.declare_parameter(
+            "lid_shake_command",
+            "bash /home/ssu/Azas/tools/run/run_lid_close_then_shake_chain.sh",
+        )
 
         self._latest_detection: Optional[CupDetection] = None
         self._latest_image: Optional[np.ndarray] = None
         self._image_lock = threading.Lock()
         self._window_enabled = bool(self.get_parameter("show_classification_window").value)
         self._children: list[subprocess.Popen[str]] = []
+        self._child_node_failures: dict[str, list[str]] = {}
 
         self.create_subscription(
             CupDetection,
@@ -96,9 +130,11 @@ def run(self) -> int:
         if not self._confirmed():
             return 2
 
-        self.get_logger().info("auto cup router: observe -> open -> classify -> route")
+        self.get_logger().info("auto cup router: color scan -> observe -> open -> classify -> route")
         perception = None
         try:
+            if not self._run_color_scan_sequence():
+                return 1
             if not self._move_observe("initial observe"):
                 return 1
             if not self._open_gripper("initial gripper full-open"):
@@ -118,6 +154,10 @@ def run(self) -> int:
                 success = self._run_cup_uprighting(decision)
             if not success:
                 return 1
+            if not self._run_recipe_sequence():
+                return 1
+            if not self._run_lid_shake_sequence():
+                return 1
             self.get_logger().info("auto cup router: selected flow completed; router exiting")
             return 0
         finally:
@@ -401,6 +441,7 @@ def _run_side_grasp(self, decision: RouteDecision) -> bool:
             "table_center_y:=0.0",
             "dispenser_collision_enabled:=true",
             f"moveit_controller_name:={self.get_parameter('moveit_controller_name').value}",
+            f"side_target_x_offset_m:={float(self.get_parameter('side_target_x_offset_m').value)}",
             "start_joint_state_relay:=false",
             f"model_path:={self.get_parameter('yolo_model_path').value}",
         ])
@@ -421,6 +462,45 @@ def _run_cup_uprighting(self, decision: RouteDecision) -> bool:
         cmd.extend(self._split_extra_args(str(self.get_parameter("cup_uprighting_extra_args").value)))
         return self._run_process(cmd, "cup_uprighting")
 
+    def _run_color_scan_sequence(self) -> bool:
+        if not bool(self.get_parameter("color_scan_at_start").value):
+            self.get_logger().info("color_scan_at_start=false; skipping dispenser color scan")
+            return True
+        command = str(self.get_parameter("color_scan_command").value).strip()
+        if not command:
+            self.get_logger().warning("color_scan_command is empty; skipping dispenser color scan")
+            return True
+        self.get_logger().info("moving to color_scan_pose and scanning dispensers before cup pick")
+        return self._run_process(["bash", "-c", command], "color_scan")
+
+    def _run_recipe_sequence(self) -> bool:
+        if not bool(self.get_parameter("recipe_after_success").value):
+            self.get_logger().info("recipe_after_success=false; skipping dispenser recipe sequence")
+            return True
+        command = str(self.get_parameter("recipe_command").value).strip()
+        if not command:
+            self.get_logger().warning("recipe_command is empty; skipping dispenser recipe sequence")
+            return True
+        colors = str(self.get_parameter("recipe_colors").value).strip()
+        if colors:
+            command += f" --colors {shlex.quote(colors)}"
+            self.get_logger().info(f"recipe colors given directly: {colors}")
+        place_z = float(self.get_parameter("cup_holder_place_z_offset_m").value)
+        command += f" --cup-holder-place-final-z-offset-m {place_z}"
+        self.get_logger().info("pick flow succeeded; starting integrated dispenser recipe sequence")
+        return self._run_process(["bash", "-c", command], "recipe")
+
+    def _run_lid_shake_sequence(self) -> bool:
+        if not bool(self.get_parameter("lid_shake_after_recipe").value):
+            self.get_logger().info("lid_shake_after_recipe=false; skipping lid close / shake chain")
+            return True
+        command = str(self.get_parameter("lid_shake_command").value).strip()
+        if not command:
+            self.get_logger().warning("lid_shake_command is empty; skipping lid close / shake chain")
+            return True
+        self.get_logger().info("recipe succeeded; starting lid close -> holder re-pick -> shake chain")
+        return self._run_process(["bash", "-c", command], "lid_shake")
+
     def _move_observe(self, label: str) -> bool:
         prefix = str(self.get_parameter("service_prefix").value).strip().strip("/")
         base = f"/{prefix}/motion" if prefix else "/motion"
@@ -490,6 +570,31 @@ def _launch_command(spec: str) -> list[str]:
     def _split_extra_args(raw: str) -> list[str]:
         return [part for part in raw.split() if part]
 
+    @staticmethod
+    def _subprocess_env() -> dict[str, str]:
+        # 다른 워크스페이스(예: ~/ros2_ws)에 같은 이름의 stale 패키지가 있으면
+        # 터미널 source 순서에 따라 자식 launch가 엉뚱한 사본을 잡을 수 있다.
+        # 이 라우터가 설치된 워크스페이스의 경로를 검색 변수 맨 앞으로 올려서
+        # 자식 프로세스가 항상 같은 워크스페이스의 패키지를 먼저 찾게 한다.
+        env = os.environ.copy()
+        try:
+            from ament_index_python.packages import get_package_prefix
+            # install/<pkg> 두 단계 위 = 워크스페이스 루트. symlink 설치는 egg-info가
+            # build/<pkg>에 있으므로 install/만 올리면 entry point 탐색이 또 어긋난다.
+            ws_root = os.path.dirname(os.path.dirname(get_package_prefix("azas_task_manager"))) + os.sep
+        except Exception:
+            return env
+        for var in ("AMENT_PREFIX_PATH", "COLCON_PREFIX_PATH", "CMAKE_PREFIX_PATH",
+                    "PYTHONPATH", "PATH", "LD_LIBRARY_PATH"):
+            value = env.get(var)
+            if not value:
+                continue
+            entries = value.split(os.pathsep)
+            own = [e for e in entries if e.startswith(ws_root) or e + os.sep == ws_root]
+            rest = [e for e in entries if e not in own]
+            env[var] = os.pathsep.join(own + rest)
+        return env
+
     def _popen(self, cmd: list[str], label: str) -> subprocess.Popen[str]:
         proc = subprocess.Popen(
             cmd,
@@ -498,6 +603,7 @@ def _popen(self, cmd: list[str], label: str) -> subprocess.Popen[str]:
             text=True,
             bufsize=1,
             preexec_fn=os.setsid,
+            env=self._subprocess_env(),
         )
         self._children.append(proc)
         threading.Thread(target=self._forward_output, args=(proc, label), daemon=True).start()
@@ -505,19 +611,39 @@ def _popen(self, cmd: list[str], label: str) -> subprocess.Popen[str]:
 
     def _run_process(self, cmd: list[str], label: str) -> bool:
         self.get_logger().info(f"{label}: " + " ".join(cmd))
+        self._child_node_failures.pop(label, None)
         proc = self._popen(cmd, label)
         code = proc.wait()
+        # ros2 launch는 내부 노드가 죽어도 exit code 0으로 끝나므로
+        # 출력에서 감지한 노드 비정상 종료를 별도로 확인한다.
+        failures = self._child_node_failures.pop(label, None)
+        if failures:
+            self.get_logger().error(f"{label}: node failure detected: " + "; ".join(failures))
+            return False
         if code == 0:
             self.get_logger().info(f"{label}: completed successfully")
             return True
         self.get_logger().error(f"{label}: process exited with code {code}")
         return False
 
+    _NODE_DIED_PATTERN = re.compile(r"\[ERROR\] \[(?P<node>[^\]]+)\]: process has died.*exit code (?P<code>-?\d+)")
+    _SHUTDOWN_PATTERN = re.compile(r"sending signal 'SIG(INT|TERM)'|user interrupted with ctrl-c")
+
     def _forward_output(self, proc: subprocess.Popen[str], label: str) -> None:
         if proc.stdout is None:
             return
+        shutting_down = False
         for line in proc.stdout:
-            self.get_logger().info(f"{label}> {line.rstrip()}")
+            text = line.rstrip()
+            self.get_logger().info(f"{label}> {text}")
+            if not shutting_down and self._SHUTDOWN_PATTERN.search(text):
+                shutting_down = True
+            match = self._NODE_DIED_PATTERN.search(text)
+            # launch 종료 신호 이후의 죽음(SIGINT 받은 KeyboardInterrupt 등)과
+            # 음수 exit code(시그널 종료)는 정상 정리 과정이므로 제외
+            if match and int(match.group("code")) > 0 and not shutting_down:
+                self._child_node_failures.setdefault(label, []).append(
+                    f"{match.group('node')} exit code {match.group('code')}")
 
     def _stop_process(self, proc: Optional[subprocess.Popen[str]], label: str) -> None:
         if proc is None or proc.poll() is not None:
diff --git a/src/dsr_practice/dsr_practice/yolo_cup_pick_node.py b/src/dsr_practice/dsr_practice/yolo_cup_pick_node.py
index bbdd73c..819822b 100644
--- a/src/dsr_practice/dsr_practice/yolo_cup_pick_node.py
+++ b/src/dsr_practice/dsr_practice/yolo_cup_pick_node.py
@@ -225,6 +225,7 @@ def __init__(self):
         self.declare_parameter("side_short_stage_backoff_m", 0.06)
         self.declare_parameter("side_stage_y_min", SAFE_Y_MIN)
         self.declare_parameter("side_stage_y_max", SAFE_Y_MAX)
+        self.declare_parameter("side_target_x_offset_m", 0.0)
         self.declare_parameter("side_grasp_offset", 0.035)
         self.declare_parameter("side_grasp_z_offset", 0.05)
         self.declare_parameter("side_grasp_stop_backoff_m", 0.04)
@@ -405,6 +406,9 @@ def __init__(self):
         )
         self.side_stage_y_min = float(self.get_parameter("side_stage_y_min").value)
         self.side_stage_y_max = float(self.get_parameter("side_stage_y_max").value)
+        self.side_target_x_offset_m = float(
+            self.get_parameter("side_target_x_offset_m").value
+        )
         self.side_grasp_offset = float(self.get_parameter("side_grasp_offset").value)
         self.side_grasp_z_offset = float(
             self.get_parameter("side_grasp_z_offset").value
@@ -640,6 +644,11 @@ def __init__(self):
                 "side_fixed_grasp_z is interpreted as a base_link Z target for "
                 f"{EE_LINK}; table/cup/lid geometry is not inferred from it."
             )
+        if abs(self.side_target_x_offset_m) > 1e-6:
+            self.get_logger().warning(
+                "side_target_x_offset_m applies only to side-grip motion planning; "
+                f"detected cup poses are left unchanged (offset={self.side_target_x_offset_m:.3f} m)."
+            )
         if not self.table_collision_enabled:
             self.get_logger().warning(
                 "table_collision_enabled=false: MoveIt will only clamp the EE target Z, "
@@ -1839,6 +1848,20 @@ def log_side_grasp_plan(self, plan: SideGraspPlan, prefix="Side grasp target"):
     def side_final_approach_params(self):
         return self.pilz_lin_params if self.side_linear_approach_enabled else self.pilz_params
 
+    def apply_side_target_offset(self, cup_base_xyz):
+        adjusted = np.array([float(v) for v in cup_base_xyz], dtype=float)
+        if abs(self.side_target_x_offset_m) <= 1e-6:
+            return adjusted
+        raw_x = float(adjusted[0])
+        adjusted[0] = raw_x + self.side_target_x_offset_m
+        self.get_logger().info(
+            "Side target X compensation: "
+            f"detected_x={raw_x:.3f} m, "
+            f"offset={self.side_target_x_offset_m:.3f} m, "
+            f"planning_x={adjusted[0]:.3f} m"
+        )
+        return adjusted
+
     def spin_for_camera_update(self, duration_sec):
         end_time = time.time() + max(0.0, duration_sec)
         while rclpy.ok() and time.time() < end_time:
@@ -2031,7 +2054,8 @@ def pick_and_place_side(self, base_xyz):
 
         refined_base = self.center_check_redetect(initial_base)
         cup_base = initial_base if refined_base is None else np.array(refined_base, dtype=float)
-        candidates = self.build_side_grasp_candidates(cup_base)
+        planning_cup_base = self.apply_side_target_offset(cup_base)
+        candidates = self.build_side_grasp_candidates(planning_cup_base)
         if not candidates:
             log.error("No side-grasp candidates generated")
             return False
@@ -2044,7 +2068,7 @@ def pick_and_place_side(self, base_xyz):
                 f"close=({candidate.guarded_grasp_xy[0]:.3f}, {candidate.guarded_grasp_xy[1]:.3f}, {candidate.pre_z:.3f})"
             )
 
-        if not self.move_to_side_prepose_if_configured(cup_base):
+        if not self.move_to_side_prepose_if_configured(planning_cup_base):
             return False
         if not self.move_joint1_clearance_before_side_grip():
             return False
diff --git a/src/dsr_practice/launch/yolo_cup_pick_node.launch.py b/src/dsr_practice/launch/yolo_cup_pick_node.launch.py
index 9401151..9034dbf 100644
--- a/src/dsr_practice/launch/yolo_cup_pick_node.launch.py
+++ b/src/dsr_practice/launch/yolo_cup_pick_node.launch.py
@@ -1,8 +1,16 @@
 from copy import deepcopy
 
 from launch import LaunchDescription
-from launch.actions import DeclareLaunchArgument, IncludeLaunchDescription, OpaqueFunction
+from launch.actions import (
+    DeclareLaunchArgument,
+    EmitEvent,
+    IncludeLaunchDescription,
+    OpaqueFunction,
+    RegisterEventHandler,
+)
 from launch.conditions import IfCondition
+from launch.event_handlers import OnProcessExit
+from launch.events import Shutdown
 from launch.launch_description_sources import PythonLaunchDescriptionSource
 from launch.substitutions import LaunchConfiguration, PathJoinSubstitution
 from launch_ros.actions import Node
@@ -167,16 +175,15 @@ def _runtime_nodes(context, moveit_params, moveit_py_params, side_prepose_params
         )
     )
 
-    nodes.append(
-        Node(
-            package="dsr_practice",
-            executable="yolo_cup_pick_node",
-            output="screen",
-            parameters=[
-                runtime_moveit_params,
-                moveit_py_params,
-                side_prepose_params,
-                {
+    yolo_node = Node(
+        package="dsr_practice",
+        executable="yolo_cup_pick_node",
+        output="screen",
+        parameters=[
+            runtime_moveit_params,
+            moveit_py_params,
+            side_prepose_params,
+            {
                     "model_path": ParameterValue(
                         LaunchConfiguration("model_path"),
                         value_type=str,
@@ -218,6 +225,9 @@ def _runtime_nodes(context, moveit_params, moveit_py_params, side_prepose_params
                     ),
                     "side_stage_y_min": LaunchConfiguration("side_stage_y_min"),
                     "side_stage_y_max": LaunchConfiguration("side_stage_y_max"),
+                    "side_target_x_offset_m": LaunchConfiguration(
+                        "side_target_x_offset_m"
+                    ),
                     "side_grasp_offset": LaunchConfiguration("side_grasp_offset"),
                     "side_grasp_z_offset": LaunchConfiguration("side_grasp_z_offset"),
                     "side_grasp_stop_backoff_m": LaunchConfiguration(
@@ -368,8 +378,22 @@ def _runtime_nodes(context, moveit_params, moveit_py_params, side_prepose_params
                     "place_y": LaunchConfiguration("place_y"),
                     "place_z": LaunchConfiguration("place_z"),
                     "auto_pick": LaunchConfiguration("auto_pick"),
-                },
-            ],
+            },
+        ],
+    )
+    nodes.append(yolo_node)
+    nodes.append(
+        RegisterEventHandler(
+            OnProcessExit(
+                target_action=yolo_node,
+                on_exit=[
+                    EmitEvent(
+                        event=Shutdown(
+                            reason="yolo_cup_pick_node exited; stopping helper nodes"
+                        )
+                    )
+                ],
+            )
         )
     )
     return nodes
@@ -471,6 +495,11 @@ def generate_launch_description():
         default_value="0.35",
         description="Maximum preferred base_link Y for side staging; side direction is flipped if the configured direction leaves this range.",
     )
+    side_target_x_offset_m_arg = DeclareLaunchArgument(
+        "side_target_x_offset_m",
+        default_value="0.0",
+        description="Planning-only base_link X compensation added to side-grip cup targets after vision/refinement.",
+    )
     side_grasp_offset_arg = DeclareLaunchArgument(
         "side_grasp_offset", default_value="0.035"
     )
@@ -571,10 +600,10 @@ def generate_launch_description():
     )
     link6_gripper_collision_enabled_arg = DeclareLaunchArgument(
         "link6_gripper_collision_enabled",
-        default_value="true",
+        default_value="false",
         description=(
-            "Publish the RG2/link_6 attached collision envelope so MoveIt plans "
-            "with the mounted gripper, not only the bare robot flange."
+            "Legacy attached RG2/link_6 box envelope. Keep false when the "
+            "mesh-based RG2 is already in the MoveIt URDF."
         ),
     )
     table_collision_enabled_arg = DeclareLaunchArgument(
@@ -841,6 +870,7 @@ def generate_launch_description():
             side_short_stage_backoff_m_arg,
             side_stage_y_min_arg,
             side_stage_y_max_arg,
+            side_target_x_offset_m_arg,
             side_grasp_offset_arg,
             side_grasp_z_offset_arg,
             side_grasp_stop_backoff_m_arg,
diff --git a/third_party/ros2_src/doosan-robot2 b/third_party/ros2_src/doosan-robot2
index 0a908f3..a759bea 160000
--- a/third_party/ros2_src/doosan-robot2
+++ b/third_party/ros2_src/doosan-robot2
@@ -1 +1 @@
-Subproject commit 0a908f31222e795e2e39ab5f187109ebbd85541b
+Subproject commit a759bea7b789e968e82c82539518c676d06c9eaa
diff --git a/tools/checks/check_hand_detection_perception_only.py b/tools/checks/check_hand_detection_perception_only.py
new file mode 100755
index 0000000..853f3ce
--- /dev/null
+++ b/tools/checks/check_hand_detection_perception_only.py
@@ -0,0 +1,45 @@
+#!/usr/bin/env python3
+"""Static guard: the hand detection node must stay perception-only (no motion)."""
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[2]
+NODE = ROOT / "tools" / "perception" / "human_hand_detection_node.py"
+
+FORBIDDEN = (
+    "MoveLine",
+    "MoveJoint",
+    "MoveWait",
+    "motion/move",
+    "SetGripper",
+    "rg2",
+    "create_client",
+)
+REQUIRED = (
+    "/azas/human_hand_detection",
+    "no_motion_hri_perception_only",
+    "PointStamped",
+)
+
+
+def main() -> int:
+    text = NODE.read_text(encoding="utf-8")
+    failures: list[str] = []
+    for needle in FORBIDDEN:
+        if needle in text:
+            failures.append(f"forbidden motion-related token present: {needle!r}")
+    for needle in REQUIRED:
+        if needle not in text:
+            failures.append(f"required token missing: {needle!r}")
+    if failures:
+        for failure in failures:
+            print(f"[FAIL] {NODE.relative_to(ROOT)}: {failure}")
+        return 1
+    print("[PASS] human hand detection node is perception-only (no motion clients, required topics present)")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/tools/checks/check_hand_detection_status.py b/tools/checks/check_hand_detection_status.py
new file mode 100755
index 0000000..f39c903
--- /dev/null
+++ b/tools/checks/check_hand_detection_status.py
@@ -0,0 +1,71 @@
+#!/usr/bin/env python3
+"""Panel check: listen to /azas/human_hand_detection/status and summarize.
+
+Perception-only (no motion command). Listens for a fixed window and reports
+how many frames detected a hand and how many passed the stability gate that
+actually publishes coordinates for the palm handover.
+
+Exit codes:
+  0  stable open-hand detections seen (handover can consume coordinates)
+  1  status is flowing but no stable open hand in the window
+  2  no status messages at all (detection node or camera is not running)
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import time
+
+import rclpy
+from std_msgs.msg import String
+
+STATUS_TOPIC = "/azas/human_hand_detection/status"
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--listen-sec", type=float, default=10.0)
+    args = parser.parse_args()
+
+    messages: list[dict] = []
+    rclpy.init()
+    node = rclpy.create_node("azas_check_hand_detection_status")
+    node.create_subscription(
+        String, STATUS_TOPIC, lambda m: messages.append(json.loads(m.data)), 10
+    )
+    print(f"[Azas] 손 검출 상태를 {args.listen_sec:.0f}초간 측정합니다 (로봇 모션 없음).")
+    deadline = time.monotonic() + args.listen_sec
+    while rclpy.ok() and time.monotonic() < deadline:
+        rclpy.spin_once(node, timeout_sec=0.2)
+    node.destroy_node()
+    if rclpy.ok():
+        rclpy.shutdown()
+
+    detected = [m for m in messages if m.get("detected")]
+    stable = [m for m in messages if m.get("stable")]
+    print(f"[Azas] 상태 메시지 {len(messages)}개 / 손 검출 {len(detected)}개 / STABLE {len(stable)}개")
+
+    if not messages:
+        print("[FAIL] 상태 메시지가 없습니다. 카메라와 '손 검출 시작' 버튼이 켜져 있는지 확인하세요.")
+        return 2
+    if not stable:
+        reasons = [str(m.get("reason", "")) for m in messages if m.get("reason")]
+        if reasons:
+            print(f"[Azas] 최근 사유: {reasons[-1]}")
+        print(
+            "[FAIL] STABLE 검출이 없습니다. 손바닥을 펴고(손가락 4개 이상), "
+            "카메라에서 0.3m 이상 떨어져 1초간 정지하세요. 텀블러가 가리는 화면 "
+            "오른쪽 아래를 피해 왼쪽/위쪽 영역에 손을 두세요."
+        )
+        return 1
+
+    last = stable[-1]
+    xyz = last.get("camera_xyz_m")
+    depth = last.get("depth_m")
+    print(f"[Azas] 마지막 STABLE: depth={depth}m camera_xyz_m={xyz} palm_px={last.get('palm_px')}")
+    print("[PASS] 안정적인 손바닥 검출이 발행되고 있습니다. 핸드오버 진행 가능.")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/tools/checks/check_panel_service_discovery_race.py b/tools/checks/check_panel_service_discovery_race.py
index dcc8c8c..89def56 100755
--- a/tools/checks/check_panel_service_discovery_race.py
+++ b/tools/checks/check_panel_service_discovery_race.py
@@ -104,6 +104,22 @@ def main() -> int:
             print("[FAIL] lid_grip_close command does not use the direct runner")
             print(lid_grip_close_command)
             return 1
+        if "MOVE_TO_LID_VIEW_POSE=true" not in lid_grip_close_command:
+            print("[FAIL] lid_grip_close command must move to lid camera view pose first")
+            print(lid_grip_close_command)
+            return 1
+        if "wait_for_lid_grip_status.py" not in lid_grip_close_command:
+            print("[FAIL] lid_grip_close command must wait for ArUco success status")
+            print(lid_grip_close_command)
+            return 1
+        if "pick_from_cup_holder_side_grip.py" not in lid_grip_close_command:
+            print("[FAIL] lid_grip_close command must chain to cup-holder re-pick")
+            print(lid_grip_close_command)
+            return 1
+        if "run_rule_based_shake_real.sh" not in lid_grip_close_command:
+            print("[FAIL] lid_grip_close command must chain to real shake")
+            print(lid_grip_close_command)
+            return 1
 
         non_tmux_background = [
             step.key
diff --git a/tools/checks/check_rg2_moveit_description.py b/tools/checks/check_rg2_moveit_description.py
new file mode 100755
index 0000000..11cbd91
--- /dev/null
+++ b/tools/checks/check_rg2_moveit_description.py
@@ -0,0 +1,160 @@
+#!/usr/bin/env python3
+"""Verify that the M0609 MoveIt description includes the RG2 collision mesh.
+
+This is a no-hardware check. It expands the MoveIt URDF xacro and verifies that
+the robot model contains the vendored OnRobot RG2FT collision links instead of
+planning with the bare robot flange only.
+"""
+
+from __future__ import annotations
+
+import argparse
+import os
+import subprocess
+import sys
+import xml.etree.ElementTree as ET
+from pathlib import Path
+
+
+ROOT = Path(__file__).resolve().parents[2]
+MOVEIT_XACRO = (
+    ROOT
+    / "third_party"
+    / "ros2_src"
+    / "doosan-robot2"
+    / "dsr_moveit2"
+    / "dsr_moveit_config_m0609"
+    / "config"
+    / "m0609.urdf.xacro"
+)
+MOVEIT_SRDF = MOVEIT_XACRO.with_name("dsr.srdf")
+
+REQUIRED_LINKS = {
+    "rg2_quick_changer",
+    "rg2_gripper_body",
+    "rg2_angle_bracket",
+    "rg2_left_inner_finger",
+    "rg2_right_inner_finger",
+    "gripper_tcp",
+}
+
+REQUIRED_DISABLED_COLLISIONS = {
+    frozenset(("link_6", "rg2_quick_changer")),
+    frozenset(("rg2_quick_changer", "rg2_angle_bracket")),
+    frozenset(("rg2_angle_bracket", "rg2_gripper_body")),
+    frozenset(("rg2_gripper_body", "rg2_left_inner_knuckle")),
+    frozenset(("rg2_gripper_body", "rg2_right_inner_knuckle")),
+    frozenset(("rg2_left_inner_knuckle", "rg2_left_inner_finger")),
+    frozenset(("rg2_right_inner_knuckle", "rg2_right_inner_finger")),
+}
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Check that M0609 MoveIt robot_description contains RG2 mesh collisions."
+    )
+    parser.add_argument("--xacro", type=Path, default=MOVEIT_XACRO)
+    parser.add_argument("--srdf", type=Path, default=MOVEIT_SRDF)
+    return parser.parse_args()
+
+
+def run_xacro(path: Path) -> str:
+    env = os.environ.copy()
+    env.setdefault("AMENT_PREFIX_PATH", str(ROOT / "install"))
+    try:
+        completed = subprocess.run(
+            ["xacro", str(path)],
+            check=True,
+            text=True,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            env=env,
+        )
+    except FileNotFoundError:
+        print("[FAIL] xacro executable not found", file=sys.stderr)
+        raise SystemExit(1)
+    except subprocess.CalledProcessError as exc:
+        print(exc.stderr, file=sys.stderr)
+        print(f"[FAIL] failed to expand xacro: {path}", file=sys.stderr)
+        raise SystemExit(exc.returncode)
+    return completed.stdout
+
+
+def main() -> int:
+    args = parse_args()
+    xacro_path = args.xacro.expanduser().resolve()
+    if not xacro_path.is_file():
+        print(f"[FAIL] missing MoveIt xacro: {xacro_path}")
+        return 1
+
+    source = xacro_path.read_text(encoding="utf-8")
+    required_source = [
+        "rg2_parametric.xacro",
+        "xacro:azas_rg2_parametric",
+        'name="rg2_parent_link" default="link_6"',
+        'name="rg2_mount_rpy" default="0 0 0"',
+    ]
+    missing_source = [needle for needle in required_source if needle not in source]
+    if missing_source:
+        print("[FAIL] MoveIt xacro does not wire the RG2 description:")
+        for needle in missing_source:
+            print(f"missing={needle}")
+        return 1
+
+    root = ET.fromstring(run_xacro(xacro_path))
+    links = {link.attrib["name"] for link in root.findall("link")}
+    missing_links = sorted(REQUIRED_LINKS - links)
+    if missing_links:
+        print(f"[FAIL] expanded robot_description missing RG2 links: {missing_links}")
+        return 1
+
+    collision_meshes = [
+        mesh.attrib.get("filename", "")
+        for mesh in root.findall(".//collision/geometry/mesh")
+    ]
+    rg2_collision_meshes = [
+        filename
+        for filename in collision_meshes
+        if filename.startswith("package://azas_description/meshes/onrobot_rg2ft/collision/")
+    ]
+    if len(rg2_collision_meshes) < 8:
+        print(f"[FAIL] expected RG2 collision meshes, found {len(rg2_collision_meshes)}")
+        return 1
+
+    quick_changer_joint = root.find("./joint[@name='rg2_quick_changer_joint']")
+    parent = quick_changer_joint.find("parent").attrib.get("link") if quick_changer_joint is not None else None
+    if parent != "link_6":
+        print(f"[FAIL] rg2_quick_changer_joint parent should be link_6, found {parent!r}")
+        return 1
+    origin = quick_changer_joint.find("origin") if quick_changer_joint is not None else None
+    mount_rpy = origin.attrib.get("rpy") if origin is not None else None
+    if mount_rpy != "0 0 0":
+        print(f"[FAIL] rg2_quick_changer_joint mount rpy should be identity, found {mount_rpy!r}")
+        return 1
+
+    srdf_path = args.srdf.expanduser().resolve()
+    if not srdf_path.is_file():
+        print(f"[FAIL] missing MoveIt SRDF: {srdf_path}")
+        return 1
+    srdf = ET.parse(srdf_path).getroot()
+    disabled_collisions = {
+        frozenset((entry.attrib.get("link1", ""), entry.attrib.get("link2", "")))
+        for entry in srdf.findall("disable_collisions")
+    }
+    missing_disabled = REQUIRED_DISABLED_COLLISIONS - disabled_collisions
+    if missing_disabled:
+        print("[FAIL] MoveIt SRDF does not allow required RG2 internal self-collisions:")
+        for pair in sorted(tuple(sorted(pair)) for pair in missing_disabled):
+            print(f"missing={pair[0]} <-> {pair[1]}")
+        return 1
+
+    print("[PASS] M0609 MoveIt robot_description includes RG2 mesh collision links.")
+    print(f"rg2_collision_meshes={len(rg2_collision_meshes)}")
+    print("rg2_parent=link_6")
+    print("rg2_mount_rpy=0 0 0")
+    print(f"rg2_required_disabled_collisions={len(REQUIRED_DISABLED_COLLISIONS)}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/tools/perception/human_hand_detection_node.py b/tools/perception/human_hand_detection_node.py
new file mode 100755
index 0000000..699dde7
--- /dev/null
+++ b/tools/perception/human_hand_detection_node.py
@@ -0,0 +1,290 @@
+#!/usr/bin/env python3
+"""Perception-only human hand detection for the post-shake handover plan.
+
+Publishes a stable open-hand 3D target on /azas/human_hand_detection as a
+geometry_msgs/PointStamped in the color camera optical frame. This node sends
+NO robot motion command of any kind; it only reads camera topics, following
+docs/post_shake_human_handover_plan.md phase VERIFY_HUMAN_HAND_TRACKING
+(gate: no_motion_hri_perception_only).
+
+Pipeline:
+  RealSense color + aligned depth -> MediaPipe HandLandmarker (tasks API)
+  -> open-palm heuristic over 21 landmarks -> palm-center pixel
+  -> median depth window -> intrinsics deprojection -> stability window
+  -> publish only while the hand stays open and spatially stable.
+
+Usage:
+  python3 tools/perception/human_hand_detection_node.py
+  python3 tools/perception/human_hand_detection_node.py --show-overlay false
+"""
+from __future__ import annotations
+
+import argparse
+import collections
+import json
+import math
+import time
+
+import cv2
+import numpy as np
+import rclpy
+from geometry_msgs.msg import PointStamped
+from rclpy.node import Node
+from sensor_msgs.msg import CameraInfo, Image
+from std_msgs.msg import String
+
+import mediapipe as mp
+from mediapipe.tasks import python as mp_python
+from mediapipe.tasks.python import vision as mp_vision
+
+DEFAULT_MODEL_PATH = "/home/ssu/Azas/models/mediapipe/hand_landmarker.task"
+COLOR_TOPIC = "/camera/camera/color/image_raw"
+DEPTH_TOPIC = "/camera/camera/aligned_depth_to_color/image_raw"
+CAMERA_INFO_TOPIC = "/camera/camera/color/camera_info"
+OUTPUT_TOPIC = "/azas/human_hand_detection"
+STATUS_TOPIC = "/azas/human_hand_detection/status"
+OVERLAY_TOPIC = "/azas/human_hand_detection/overlay"
+
+WRIST = 0
+PALM_LANDMARKS = (0, 5, 9, 13, 17)
+FINGER_TIPS = (8, 12, 16, 20)
+FINGER_PIPS = (6, 10, 14, 18)
+
+
+# cv_bridge is avoided on purpose: the ROS humble build is ABI-incompatible
+# with the pip-installed numpy 2.x that mediapipe requires.
+def image_msg_to_array(msg: Image) -> np.ndarray:
+    if msg.encoding in ("bgr8", "rgb8"):
+        array = np.frombuffer(msg.data, dtype=np.uint8).reshape(msg.height, msg.width, 3)
+        return cv2.cvtColor(array, cv2.COLOR_RGB2BGR) if msg.encoding == "rgb8" else array.copy()
+    if msg.encoding == "16UC1":
+        dtype = np.dtype(np.uint16).newbyteorder(">" if msg.is_bigendian else "<")
+        return np.frombuffer(msg.data, dtype=dtype).reshape(msg.height, msg.width)
+    if msg.encoding == "32FC1":
+        dtype = np.dtype(np.float32).newbyteorder(">" if msg.is_bigendian else "<")
+        return np.frombuffer(msg.data, dtype=dtype).reshape(msg.height, msg.width)
+    raise ValueError(f"unsupported image encoding: {msg.encoding}")
+
+
+def bgr_array_to_image_msg(array: np.ndarray, header) -> Image:
+    msg = Image()
+    msg.header = header
+    msg.height, msg.width = array.shape[:2]
+    msg.encoding = "bgr8"
+    msg.is_bigendian = 0
+    msg.step = msg.width * 3
+    msg.data = np.ascontiguousarray(array).tobytes()
+    return msg
+
+
+class HumanHandDetectionNode(Node):
+    """Perception-only node: no motion service client is created here."""
+
+    def __init__(self, args: argparse.Namespace) -> None:
+        super().__init__("azas_human_hand_detection")
+        self.args = args
+        self.camera_info: CameraInfo | None = None
+        self.latest_depth: np.ndarray | None = None
+        self.latest_depth_encoding = ""
+        self.last_process_monotonic = 0.0
+        self.last_timestamp_ms = 0
+        # Recent accepted (monotonic_time, xyz_m) detections for the stability gate.
+        self.recent: collections.deque[tuple[float, tuple[float, float, float]]] = collections.deque(maxlen=64)
+
+        options = mp_vision.HandLandmarkerOptions(
+            base_options=mp_python.BaseOptions(model_asset_path=args.model_path),
+            running_mode=mp_vision.RunningMode.VIDEO,
+            num_hands=1,
+            min_hand_detection_confidence=args.min_detection_confidence,
+            min_tracking_confidence=args.min_tracking_confidence,
+        )
+        self.landmarker = mp_vision.HandLandmarker.create_from_options(options)
+
+        self.point_pub = self.create_publisher(PointStamped, OUTPUT_TOPIC, 10)
+        self.status_pub = self.create_publisher(String, STATUS_TOPIC, 10)
+        self.overlay_pub = self.create_publisher(Image, OVERLAY_TOPIC, 2) if args.show_overlay else None
+
+        self.create_subscription(CameraInfo, CAMERA_INFO_TOPIC, self.on_camera_info, 10)
+        self.create_subscription(Image, DEPTH_TOPIC, self.on_depth, 5)
+        self.create_subscription(Image, COLOR_TOPIC, self.on_color, 5)
+
+        self.get_logger().info(
+            "human hand detection ready (perception-only, no motion commands). "
+            f"publishing stable open-hand target on {OUTPUT_TOPIC}; "
+            f"stability: {args.stable_min_samples} samples within {args.stable_radius_m:.3f}m "
+            f"over >= {args.stable_min_seconds:.2f}s"
+        )
+
+    def on_camera_info(self, msg: CameraInfo) -> None:
+        self.camera_info = msg
+
+    def on_depth(self, msg: Image) -> None:
+        self.latest_depth = image_msg_to_array(msg)
+        self.latest_depth_encoding = msg.encoding
+
+    def on_color(self, msg: Image) -> None:
+        now = time.monotonic()
+        if now - self.last_process_monotonic < 1.0 / max(self.args.max_rate_hz, 0.5):
+            return
+        self.last_process_monotonic = now
+        if self.camera_info is None or self.latest_depth is None:
+            self.publish_status({"detected": False, "reason": "waiting for camera_info/depth"})
+            return
+
+        color = image_msg_to_array(msg)
+        rgb = cv2.cvtColor(color, cv2.COLOR_BGR2RGB)
+        timestamp_ms = max(int(now * 1000.0), self.last_timestamp_ms + 1)
+        self.last_timestamp_ms = timestamp_ms
+        mp_image = mp.Image(image_format=mp.ImageFormat.SRGB, data=rgb)
+        result = self.landmarker.detect_for_video(mp_image, timestamp_ms)
+
+        overlay = color if self.overlay_pub is not None else None
+        status: dict[str, object] = {"detected": False}
+        try:
+            if not result.hand_landmarks:
+                self.recent.clear()
+                status["reason"] = "no hand"
+                return
+            landmarks = result.hand_landmarks[0]
+            height, width = color.shape[:2]
+            pixels = [(lm.x * width, lm.y * height) for lm in landmarks]
+            open_fingers = self.count_extended_fingers(pixels)
+            hand_open = open_fingers >= self.args.min_extended_fingers
+            palm_px = (
+                int(np.clip(np.mean([pixels[i][0] for i in PALM_LANDMARKS]), 0, width - 1)),
+                int(np.clip(np.mean([pixels[i][1] for i in PALM_LANDMARKS]), 0, height - 1)),
+            )
+            depth_m = self.median_depth_m(palm_px)
+            status.update(
+                {
+                    "detected": True,
+                    "open_fingers": open_fingers,
+                    "hand_open": hand_open,
+                    "palm_px": list(palm_px),
+                    "depth_m": None if depth_m is None else round(depth_m, 4),
+                }
+            )
+            if overlay is not None:
+                for px, py in pixels:
+                    cv2.circle(overlay, (int(px), int(py)), 3, (0, 255, 0) if hand_open else (0, 165, 255), -1)
+                cv2.circle(overlay, palm_px, 8, (255, 0, 0), 2)
+
+            if not hand_open:
+                self.recent.clear()
+                status["reason"] = f"hand not open ({open_fingers} extended fingers)"
+                return
+            if depth_m is None:
+                self.recent.clear()
+                status["reason"] = "no valid depth at palm"
+                return
+
+            xyz = self.deproject(palm_px, depth_m)
+            status["camera_xyz_m"] = [round(v, 4) for v in xyz]
+            self.recent.append((now, xyz))
+            stable = self.is_stable(now, xyz)
+            status["stable"] = stable
+            status["stability_samples"] = len(self.recent)
+            if overlay is not None:
+                label = f"hand {'STABLE' if stable else 'tracking'} z={depth_m:.2f}m"
+                cv2.putText(overlay, label, (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.8,
+                            (0, 255, 0) if stable else (0, 165, 255), 2)
+            if not stable:
+                return
+
+            point = PointStamped()
+            point.header.stamp = msg.header.stamp
+            point.header.frame_id = msg.header.frame_id or "camera_color_optical_frame"
+            point.point.x, point.point.y, point.point.z = xyz
+            self.point_pub.publish(point)
+        finally:
+            self.publish_status(status)
+            if overlay is not None and self.overlay_pub is not None:
+                self.overlay_pub.publish(bgr_array_to_image_msg(overlay, msg.header))
+
+    def count_extended_fingers(self, pixels: list[tuple[float, float]]) -> int:
+        """A finger counts as extended when its tip is farther from the wrist than its PIP joint."""
+        wrist = pixels[WRIST]
+        count = 0
+        for tip, pip in zip(FINGER_TIPS, FINGER_PIPS):
+            tip_dist = math.dist(pixels[tip], wrist)
+            pip_dist = math.dist(pixels[pip], wrist)
+            if tip_dist > pip_dist * 1.05:
+                count += 1
+        return count
+
+    def median_depth_m(self, palm_px: tuple[int, int]) -> float | None:
+        depth = self.latest_depth
+        if depth is None:
+            return None
+        half = max(int(self.args.depth_window_px) // 2, 1)
+        y0 = max(palm_px[1] - half, 0)
+        y1 = min(palm_px[1] + half + 1, depth.shape[0])
+        x0 = max(palm_px[0] - half, 0)
+        x1 = min(palm_px[0] + half + 1, depth.shape[1])
+        window = depth[y0:y1, x0:x1].astype(np.float64)
+        scale = 0.001 if self.latest_depth_encoding == "16UC1" else 1.0
+        values = window.flatten() * scale
+        values = values[(values >= self.args.min_depth_m) & (values <= self.args.max_depth_m)]
+        if values.size < 3:
+            return None
+        return float(np.median(values))
+
+    def deproject(self, pixel: tuple[int, int], depth_m: float) -> tuple[float, float, float]:
+        k = self.camera_info.k
+        fx, fy, cx, cy = k[0], k[4], k[2], k[5]
+        x = (pixel[0] - cx) / fx * depth_m
+        y = (pixel[1] - cy) / fy * depth_m
+        return (x, y, depth_m)
+
+    def is_stable(self, now: float, xyz: tuple[float, float, float]) -> bool:
+        window = [item for item in self.recent if now - item[0] <= self.args.stable_window_seconds]
+        if len(window) < self.args.stable_min_samples:
+            return False
+        if now - window[0][0] < self.args.stable_min_seconds:
+            return False
+        return all(math.dist(item[1], xyz) <= self.args.stable_radius_m for item in window)
+
+    def publish_status(self, status: dict[str, object]) -> None:
+        msg = String()
+        msg.data = json.dumps(status)
+        self.status_pub.publish(msg)
+
+
+def parse_bool(value: str) -> bool:
+    return str(value).strip().lower() in {"1", "true", "yes", "on"}
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("--model-path", default=DEFAULT_MODEL_PATH)
+    parser.add_argument("--max-rate-hz", type=float, default=15.0)
+    parser.add_argument("--min-detection-confidence", type=float, default=0.6)
+    parser.add_argument("--min-tracking-confidence", type=float, default=0.6)
+    parser.add_argument("--min-extended-fingers", type=int, default=4,
+                        help="open-palm gate: required extended fingers out of 4 (thumb excluded)")
+    parser.add_argument("--depth-window-px", type=int, default=7)
+    parser.add_argument("--min-depth-m", type=float, default=0.3)
+    parser.add_argument("--max-depth-m", type=float, default=1.5)
+    parser.add_argument("--stable-radius-m", type=float, default=0.05,
+                        help="all samples in the stability window must stay inside this radius")
+    parser.add_argument("--stable-min-samples", type=int, default=8)
+    parser.add_argument("--stable-min-seconds", type=float, default=0.8)
+    parser.add_argument("--stable-window-seconds", type=float, default=1.5)
+    parser.add_argument("--show-overlay", type=parse_bool, default=True)
+    args = parser.parse_args()
+
+    rclpy.init()
+    node = HumanHandDetectionNode(args)
+    try:
+        rclpy.spin(node)
+    except KeyboardInterrupt:
+        pass
+    finally:
+        node.destroy_node()
+        if rclpy.ok():
+            rclpy.shutdown()
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/tools/run/auto_handover_on_palm.py b/tools/run/auto_handover_on_palm.py
new file mode 100755
index 0000000..1f04164
--- /dev/null
+++ b/tools/run/auto_handover_on_palm.py
@@ -0,0 +1,129 @@
+#!/usr/bin/env python3
+"""One-shot auto handover: wait for a stable open palm, then hand the cup over.
+
+Panel flow "손 보이면 자동 핸드오버": this watcher holds NO motion of its own.
+It only listens to /azas/human_hand_detection (published by
+run_human_hand_detection.sh ONLY while an open palm stays spatially stable)
+and, once the palm has been continuously stable for the trigger window, runs
+the existing gated handover script tools/run/handover_cup_to_palm.py exactly
+once and exits with its return code.
+
+Layered safety (kept from the manual flow):
+  - trigger needs N stable detections inside a sliding window (person must
+    hold the palm open and still BEFORE the robot starts at all)
+  - handover_cup_to_palm.py then re-samples the palm itself, checks workspace
+    bounds, re-checks the palm before descent, and aborts on any force spike
+  - one-shot: after one attempt (success or abort) this watcher exits, so the
+    robot never re-launches at a hand by itself
+
+Usage:
+  python3 tools/run/auto_handover_on_palm.py                      # dry-run
+  python3 tools/run/auto_handover_on_palm.py --execute --confirm AUTO_HANDOVER_ON_PALM
+"""
+from __future__ import annotations
+
+import argparse
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[2]
+HANDOVER_SCRIPT = ROOT / "tools" / "run" / "handover_cup_to_palm.py"
+HAND_TOPIC = "/azas/human_hand_detection"
+CONFIRM_PHRASE = "AUTO_HANDOVER_ON_PALM"
+
+
+def wait_for_stable_palm(args: argparse.Namespace) -> bool:
+    """Spin a perception-only node until the palm trigger fires or we time out."""
+    import rclpy
+    from geometry_msgs.msg import PointStamped
+
+    stamps: list[float] = []
+    rclpy.init()
+    node = rclpy.create_node("azas_auto_handover_watch")
+    node.create_subscription(
+        PointStamped, HAND_TOPIC, lambda _msg: stamps.append(time.monotonic()), 10
+    )
+    print(
+        f"[Azas] 손 대기 시작: {args.trigger_window_sec:.1f}초 안에 안정 검출 "
+        f"{args.trigger_stable_count}개가 쌓이면 핸드오버를 1회 실행합니다 "
+        f"(최대 {args.wait_timeout_sec:.0f}초 대기, 대기 중 로봇 모션 없음)."
+    )
+    deadline = time.monotonic() + args.wait_timeout_sec
+    last_report = 0.0
+    triggered = False
+    try:
+        while rclpy.ok() and time.monotonic() < deadline:
+            rclpy.spin_once(node, timeout_sec=0.2)
+            now = time.monotonic()
+            stamps[:] = [t for t in stamps if now - t <= args.trigger_window_sec]
+            if len(stamps) >= args.trigger_stable_count:
+                triggered = True
+                break
+            if now - last_report >= 5.0:
+                last_report = now
+                remain = deadline - now
+                print(
+                    f"[Azas] 대기 중... 최근 {args.trigger_window_sec:.1f}초 안정 검출 "
+                    f"{len(stamps)}/{args.trigger_stable_count}개 (남은 시간 {remain:.0f}초). "
+                    "손바닥을 펴고 정지해 주세요."
+                )
+    finally:
+        node.destroy_node()
+        if rclpy.ok():
+            rclpy.shutdown()
+    return triggered
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("--service-prefix", default="dsr01")
+    parser.add_argument("--trigger-stable-count", type=int, default=12,
+                        help="trigger when this many stable detections land inside the window")
+    parser.add_argument("--trigger-window-sec", type=float, default=3.0)
+    parser.add_argument("--wait-timeout-sec", type=float, default=180.0,
+                        help="give up (exit 3, no motion) when no stable palm appears in time")
+    parser.add_argument("--release-tcp-above-palm-m", default="0.08")
+    parser.add_argument("--execute", action="store_true")
+    parser.add_argument("--confirm", default="", help=f"must equal {CONFIRM_PHRASE} with --execute")
+    args = parser.parse_args()
+
+    if args.execute and args.confirm != CONFIRM_PHRASE:
+        print(f"[BLOCKED] --execute requires --confirm {CONFIRM_PHRASE}")
+        return 2
+    if not args.execute:
+        print("[DRY-RUN] --execute 미지정: 손 트리거 후 핸드오버도 dry-run(인식+계획만)으로 실행합니다.")
+
+    if not wait_for_stable_palm(args):
+        print(
+            f"[FAIL] {args.wait_timeout_sec:.0f}초 안에 안정적인 손바닥이 없어 종료합니다 (로봇 모션 없음). "
+            "손 검출 화면에서 STABLE이 뜨는 위치를 확인한 뒤 다시 실행하세요."
+        )
+        return 3
+
+    print("[Azas] 손 트리거 충족. 핸드오버를 1회 실행합니다 (이후 자동 재시도 없음).")
+    cmd = [
+        sys.executable, str(HANDOVER_SCRIPT),
+        "--service-prefix", args.service_prefix,
+        "--release-tcp-above-palm-m", str(args.release_tcp_above_palm_m),
+        "--transit-velocity", "10.0", "--transit-acceleration", "14.0",
+        "--descent-velocity", "4.0", "--descent-acceleration", "6.0",
+        "--force-abort-delta-n", "10.0",
+    ]
+    if args.execute:
+        cmd += [
+            "--execute", "--confirm", "ENABLE_HUMAN_PALM_HANDOVER",
+            "--approve-motion", "ENABLE_HUMAN_PALM_HANDOVER_MOTION",
+            "--approve-release", "RELEASE_CUP_NOW",
+        ]
+    rc = subprocess.run(cmd, cwd=str(ROOT), check=False).returncode
+    if rc == 0:
+        print("[PASS] 자동 핸드오버 완료.")
+    else:
+        print(f"[FAIL] 핸드오버가 비정상 종료했습니다 (rc={rc}); 위 로그를 확인하세요.")
+    return rc
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/tools/run/check_one_click_cocktail_config.sh b/tools/run/check_one_click_cocktail_config.sh
index 34ac73a..e45cfba 100755
--- a/tools/run/check_one_click_cocktail_config.sh
+++ b/tools/run/check_one_click_cocktail_config.sh
@@ -89,6 +89,7 @@ try:
             raise ValueError(f"dispenser_outlets.{dispenser_id} missing in {calibration_path}")
         require_list(outlet, "press_pose_xyz_m", 3, f"dispenser_outlets.{dispenser_id}")
         require_list(outlet, "press_pose_rpy_deg", 3, f"dispenser_outlets.{dispenser_id}")
+        require_list(outlet, "press_pre_joints_deg", 6, f"dispenser_outlets.{dispenser_id}")
         require_list(outlet, "press_contact_joints_deg", 6, f"dispenser_outlets.{dispenser_id}")
 
     grouped: list[tuple[str, int]] = []
diff --git a/tools/run/check_one_click_cocktail_result.sh b/tools/run/check_one_click_cocktail_result.sh
index 030d95c..51bc4a9 100755
--- a/tools/run/check_one_click_cocktail_result.sh
+++ b/tools/run/check_one_click_cocktail_result.sh
@@ -52,8 +52,10 @@ fi
 for needle in \
   'RG2 full-open release complete; continuing only after open settle wait' \
   'RG2 close empty gripper for dispenser press' \
-  'move to measured press contact joints exactly' \
-  'press dispenser pump' \
+  'PRESS_PRE measured press pre-contact joints' \
+  'PRESS_CONTACT measured contact joints' \
+  'PRESS_Z_OVERDRIVE from measured contact' \
+  'return to PRESS_CONTACT after Z overdrive' \
   'RG2 soft side-grasp' \
   'post-grasp lift'; do
   if grep -q "${needle}" "${INTEGRATED_LOG}"; then
diff --git a/tools/run/handover_cup_to_palm.py b/tools/run/handover_cup_to_palm.py
new file mode 100755
index 0000000..11c0fbd
--- /dev/null
+++ b/tools/run/handover_cup_to_palm.py
@@ -0,0 +1,378 @@
+#!/usr/bin/env python3
+"""Pattern-A human handover: place the side-gripped cup onto an open palm.
+
+This is an HRI motion (the robot moves toward a person). It follows
+docs/post_shake_human_handover_plan.md with every gate kept explicit:
+
+  1. PERCEPTION   sample /azas/human_hand_detection (run the detector first:
+                  bash tools/run/run_human_hand_detection.sh) and transform the
+                  palm into base frame via live TF base_link->link_6 and the
+                  measured T_gripper2camera hand-eye calibration.
+  2. PLAN         compute LIFT -> ABOVE_HIGH -> ABOVE_PALM -> staged descent
+                  -> RELEASE -> RETREAT, all with the CURRENT side-grip
+                  orientation preserved (--use-current-rpy on every MoveLine).
+  3. GATES        default is dry-run. --execute needs --confirm, a typed
+                  operator approval before any motion, a hand re-check right
+                  before the descent, force-monitored descent steps, and a
+                  second typed approval before the gripper opens.
+
+Every Cartesian move is delegated to tools/run/direct_movel_xyz.py, which
+enforces workspace bounds, IK precheck, and target verification on its own.
+
+First-run advice: validate with a foam block or an empty palm-height surface
+before any person, and tune --release-tcp-above-palm-m from that test.
+
+Usage:
+  python3 tools/run/handover_cup_to_palm.py                      # dry-run plan
+  python3 tools/run/handover_cup_to_palm.py --execute --confirm ENABLE_HUMAN_PALM_HANDOVER
+"""
+from __future__ import annotations
+
+import argparse
+import math
+import os
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+import numpy as np
+
+ROOT = Path(__file__).resolve().parents[2]
+DIRECT_MOVEL = ROOT / "tools" / "run" / "direct_movel_xyz.py"
+RG2_OPEN = ROOT / "tools" / "run" / "rg2_full_open_verify.sh"
+DEFAULT_HAND_EYE = ROOT / "src" / "azas_perception" / "config" / "T_gripper2camera.npy"
+HAND_TOPIC = "/azas/human_hand_detection"
+CONFIRM_PHRASE = "ENABLE_HUMAN_PALM_HANDOVER"
+MOTION_APPROVAL_PHRASE = "ENABLE_HUMAN_PALM_HANDOVER_MOTION"
+RELEASE_APPROVAL_PHRASE = "RELEASE_CUP_NOW"
+DIRECT_CONFIRM_PHRASE = "ENABLE_DIRECT_MOVEL"
+
+
+class HandoverPerception:
+    """rclpy helpers: palm sampling, live TCP pose, tool force. No motion."""
+
+    def __init__(self, args: argparse.Namespace) -> None:
+        import rclpy
+        import tf2_ros
+        from dsr_msgs2.srv import GetCurrentPosx, GetToolForce
+        from geometry_msgs.msg import PointStamped
+
+        self.args = args
+        self.rclpy = rclpy
+        rclpy.init(args=None)
+        self.node = rclpy.create_node("azas_handover_cup_to_palm")
+        self.tf_buffer = tf2_ros.Buffer()
+        self.tf_listener = tf2_ros.TransformListener(self.tf_buffer, self.node)
+        prefix = args.service_prefix
+        self.get_posx = self.node.create_client(GetCurrentPosx, f"/{prefix}/aux_control/get_current_posx")
+        self.get_tool_force = self.node.create_client(GetToolForce, f"/{prefix}/aux_control/get_tool_force")
+        self.hand_points: list[tuple[float, list[float]]] = []
+        self.node.create_subscription(PointStamped, HAND_TOPIC, self._on_hand, 10)
+        self.gripper2cam = np.load(str(args.hand_eye_npy)).astype(float)
+        if abs(self.gripper2cam[:3, 3]).max() > 10.0:
+            self.gripper2cam[:3, 3] /= 1000.0
+
+    def close(self) -> None:
+        self.node.destroy_node()
+        if self.rclpy.ok():
+            self.rclpy.shutdown()
+
+    def _on_hand(self, msg) -> None:
+        self.hand_points.append((time.monotonic(), [msg.point.x, msg.point.y, msg.point.z]))
+
+    def _call(self, client, request, *, label: str, retries: int = 2):
+        if not client.wait_for_service(timeout_sec=self.args.wait_service_sec):
+            raise RuntimeError(f"{label} service unavailable")
+        # Doosan aux services can time out on the first cold call; retry once.
+        for attempt in range(1, retries + 1):
+            future = client.call_async(request)
+            self.rclpy.spin_until_future_complete(self.node, future, timeout_sec=self.args.wait_service_sec)
+            response = future.result()
+            if response is not None:
+                return response
+            print(f"[Azas] {label} attempt {attempt}/{retries} timed out; retrying", file=sys.stderr)
+        raise RuntimeError(f"{label} timed out after {retries} attempts")
+
+    def current_posx(self) -> list[float]:
+        from dsr_msgs2.srv import GetCurrentPosx
+
+        req = GetCurrentPosx.Request()
+        req.ref = 0  # DR_BASE
+        response = self._call(self.get_posx, req, label="GetCurrentPosx")
+        if not response.success or not response.task_pos_info:
+            raise RuntimeError("GetCurrentPosx returned success=false")
+        return [float(v) for v in list(response.task_pos_info[0].data)[:6]]
+
+    def tool_force_n(self) -> list[float]:
+        from dsr_msgs2.srv import GetToolForce
+
+        req = GetToolForce.Request()
+        req.ref = 0
+        response = self._call(self.get_tool_force, req, label="GetToolForce")
+        if not response.success:
+            raise RuntimeError("GetToolForce returned success=false")
+        return [float(v) for v in list(response.tool_force)[:3]]
+
+    def base_to_camera(self) -> np.ndarray:
+        import rclpy.time
+
+        deadline = time.monotonic() + self.args.wait_service_sec
+        last_error = ""
+        while time.monotonic() < deadline:
+            self.rclpy.spin_once(self.node, timeout_sec=0.05)
+            try:
+                t = self.tf_buffer.lookup_transform("base_link", "link_6", rclpy.time.Time())
+                break
+            except Exception as exc:  # tf2 exception types vary by install
+                last_error = str(exc)
+        else:
+            raise RuntimeError(f"TF base_link->link_6 unavailable: {last_error}")
+        q = t.transform.rotation
+        tr = t.transform.translation
+        xx, yy, zz, ww = q.x, q.y, q.z, q.w
+        rot = np.array(
+            [
+                [1 - 2 * (yy * yy + zz * zz), 2 * (xx * yy - zz * ww), 2 * (xx * zz + yy * ww)],
+                [2 * (xx * yy + zz * ww), 1 - 2 * (xx * xx + zz * zz), 2 * (yy * zz - xx * ww)],
+                [2 * (xx * zz - yy * ww), 2 * (yy * zz + xx * ww), 1 - 2 * (xx * xx + yy * yy)],
+            ]
+        )
+        base2ee = np.eye(4)
+        base2ee[:3, :3] = rot
+        base2ee[:3, 3] = [tr.x, tr.y, tr.z]
+        return base2ee @ self.gripper2cam
+
+    def sample_palm_base(self, *, label: str) -> list[float]:
+        """Collect stable hand detections and return the palm in base frame (m)."""
+        if self.args.test_hand_xyz_m:
+            xyz = [float(v) for v in self.args.test_hand_xyz_m.split(",")]
+            print(f"[Azas] {label}: TEST palm injected at base xyz={xyz} (no camera sample)")
+            return xyz
+        self.hand_points.clear()
+        deadline = time.monotonic() + self.args.hand_sample_timeout_sec
+        while time.monotonic() < deadline and len(self.hand_points) < self.args.hand_sample_count:
+            self.rclpy.spin_once(self.node, timeout_sec=0.1)
+        if len(self.hand_points) < self.args.hand_sample_count:
+            raise RuntimeError(
+                f"{label}: only {len(self.hand_points)}/{self.args.hand_sample_count} stable hand "
+                f"detections within {self.args.hand_sample_timeout_sec:.1f}s; is "
+                "run_human_hand_detection.sh running and the palm open and steady?"
+            )
+        base2cam = self.base_to_camera()
+        base_points = []
+        for _, cam_xyz in self.hand_points[-self.args.hand_sample_count:]:
+            base_points.append((base2cam @ np.array([*cam_xyz, 1.0]))[:3])
+        base_points = np.array(base_points)
+        spread = float(np.max(np.linalg.norm(base_points - base_points.mean(axis=0), axis=1)))
+        palm = base_points.mean(axis=0).tolist()
+        print(
+            f"[Azas] {label}: palm_base_m=[{palm[0]:.3f}, {palm[1]:.3f}, {palm[2]:.3f}] "
+            f"samples={len(base_points)} spread={spread * 1000.0:.1f}mm"
+        )
+        if spread > self.args.hand_sample_spread_max_m:
+            raise RuntimeError(
+                f"{label}: palm samples spread {spread * 1000.0:.1f}mm exceeds "
+                f"{self.args.hand_sample_spread_max_m * 1000.0:.1f}mm; hand or robot is moving"
+            )
+        return palm
+
+
+def run_movel(args: argparse.Namespace, xyz_m: list[float], *, label: str, velocity: float, acceleration: float) -> None:
+    cmd = [
+        sys.executable, str(DIRECT_MOVEL),
+        "--service-prefix", args.service_prefix,
+        "--x", f"{xyz_m[0]:.6f}", "--y", f"{xyz_m[1]:.6f}", "--z", f"{xyz_m[2]:.6f}",
+        "--use-current-rpy",
+        "--velocity", f"{velocity:.3f}",
+        "--acceleration", f"{acceleration:.3f}",
+        "--timeout-sec", f"{args.move_timeout_sec:.1f}",
+        "--wait-service-sec", f"{args.wait_service_sec:.1f}",
+        "--x-min", f"{args.x_min:.3f}", "--x-max", f"{args.x_max:.3f}",
+        "--y-min", f"{args.y_min:.3f}", "--y-max", f"{args.y_max:.3f}",
+        "--z-min", f"{args.z_min:.3f}", "--z-max", f"{args.z_max:.3f}",
+    ]
+    if args.execute:
+        cmd += ["--precheck-ikin", "--verify-target", "--execute", "--confirm", DIRECT_CONFIRM_PHRASE]
+    print(f"[Azas] MOVE {label}: xyz_m=[{xyz_m[0]:.3f}, {xyz_m[1]:.3f}, {xyz_m[2]:.3f}] vel={velocity:.1f}")
+    rc = subprocess.run(cmd, cwd=str(ROOT), check=False).returncode
+    if rc != 0:
+        raise RuntimeError(f"MoveLine step failed: {label} (rc={rc})")
+
+
+def open_gripper(args: argparse.Namespace) -> None:
+    env = os.environ.copy()
+    env.setdefault("RG2_OPEN_TIMEOUT_SEC", "20.0")
+    rc = subprocess.run([str(RG2_OPEN)], cwd=str(ROOT), env=env, check=False).returncode
+    if rc != 0:
+        raise RuntimeError(f"RG2 open failed (rc={rc})")
+
+
+def require_typed_approval(phrase: str, *, prompt: str, preapproved: str = "") -> None:
+    print(prompt)
+    if preapproved.strip() == phrase:
+        print(f"[Azas] approval {phrase} supplied non-interactively (panel/wrapper mode)")
+        return
+    entered = input(f"Type {phrase} to continue: ").strip()
+    if entered != phrase:
+        raise RuntimeError(f"operator approval mismatch; expected {phrase}")
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("--service-prefix", default="dsr01")
+    parser.add_argument("--hand-eye-npy", type=Path, default=DEFAULT_HAND_EYE)
+    parser.add_argument("--hand-sample-count", type=int, default=10)
+    parser.add_argument("--hand-sample-timeout-sec", type=float, default=20.0)
+    parser.add_argument("--hand-sample-spread-max-m", type=float, default=0.03)
+    parser.add_argument("--hand-recheck-tolerance-m", type=float, default=0.05,
+                        help="abort if the palm moved more than this between plan and descent")
+    parser.add_argument("--transit-z-m", type=float, default=0.45)
+    parser.add_argument("--above-palm-m", type=float, default=0.12,
+                        help="TCP height above the palm before the staged descent")
+    parser.add_argument("--release-tcp-above-palm-m", type=float, default=0.08,
+                        help="TCP height above the palm at release. TUNE WITH A FOAM-BLOCK "
+                             "DRY TEST FIRST: depends on where the side grip holds the cup")
+    parser.add_argument("--descent-step-m", type=float, default=0.02)
+    parser.add_argument("--force-abort-delta-n", type=float, default=10.0,
+                        help="abort descent when |tool force| rises this much over the pre-descent baseline")
+    parser.add_argument("--retreat-lift-m", type=float, default=0.20)
+    parser.add_argument("--transit-velocity", type=float, default=10.0)
+    parser.add_argument("--transit-acceleration", type=float, default=14.0)
+    parser.add_argument("--descent-velocity", type=float, default=4.0)
+    parser.add_argument("--descent-acceleration", type=float, default=6.0)
+    # Palm workspace bounds (base frame). The palm itself must be inside these.
+    parser.add_argument("--x-min", type=float, default=0.25)
+    parser.add_argument("--x-max", type=float, default=0.75)
+    parser.add_argument("--y-min", type=float, default=-0.45)
+    parser.add_argument("--y-max", type=float, default=0.45)
+    parser.add_argument("--z-min", type=float, default=0.05)
+    parser.add_argument("--z-max", type=float, default=0.60)
+    parser.add_argument("--palm-z-max-m", type=float, default=0.40,
+                        help="reject palms higher than this (likely a mis-detection)")
+    parser.add_argument("--move-timeout-sec", type=float, default=60.0)
+    parser.add_argument("--wait-service-sec", type=float, default=10.0)
+    parser.add_argument("--auto-release", action="store_true",
+                        help="skip the final typed release approval (NOT recommended)")
+    parser.add_argument("--test-hand-xyz-m", default="",
+                        help="debug: skip camera sampling and use this base-frame palm 'x,y,z' (meters)")
+    parser.add_argument("--execute", action="store_true")
+    parser.add_argument("--confirm", default="", help=f"must equal {CONFIRM_PHRASE} with --execute")
+    parser.add_argument("--approve-motion", default="",
+                        help=f"non-interactive operator approval; must equal {MOTION_APPROVAL_PHRASE} "
+                             "(for panel/wrapper use where stdin is unavailable)")
+    parser.add_argument("--approve-release", default="",
+                        help=f"non-interactive release approval; must equal {RELEASE_APPROVAL_PHRASE}")
+    return parser.parse_args()
+
+
+def main() -> int:
+    args = parse_args()
+    if args.execute and args.confirm != CONFIRM_PHRASE:
+        print(f"[BLOCKED] --execute requires --confirm {CONFIRM_PHRASE}")
+        return 2
+    if not args.hand_eye_npy.is_file():
+        print(f"[FAIL] hand-eye calibration not found: {args.hand_eye_npy}")
+        return 2
+    if args.release_tcp_above_palm_m >= args.above_palm_m:
+        print("[BLOCKED] --release-tcp-above-palm-m must be below --above-palm-m")
+        return 2
+    if not args.execute:
+        print("[DRY-RUN] --execute not set; perception + plan only, no robot command sent.")
+
+    perception = HandoverPerception(args)
+    try:
+        # --- PERCEPTION + PLAN (no motion) ---
+        current = perception.current_posx()
+        current_m = [v / 1000.0 for v in current[:3]]
+        print(
+            f"[Azas] current TCP: xyz_m=[{current_m[0]:.3f}, {current_m[1]:.3f}, {current_m[2]:.3f}] "
+            f"rpy_deg=[{current[3]:.1f}, {current[4]:.1f}, {current[5]:.1f}] (orientation is preserved)"
+        )
+        palm = perception.sample_palm_base(label="palm plan sample")
+        if not (args.x_min <= palm[0] <= args.x_max and args.y_min <= palm[1] <= args.y_max
+                and args.z_min <= palm[2] <= min(args.z_max, args.palm_z_max_m)):
+            print(f"[BLOCKED] palm outside handover workspace bounds; refusing: palm={palm}")
+            return 1
+
+        lift = [current_m[0], current_m[1], max(current_m[2], args.transit_z_m)]
+        above_high = [palm[0], palm[1], max(args.transit_z_m, palm[2] + args.above_palm_m)]
+        above_palm = [palm[0], palm[1], palm[2] + args.above_palm_m]
+        release = [palm[0], palm[1], palm[2] + args.release_tcp_above_palm_m]
+        retreat = [palm[0], palm[1], palm[2] + args.retreat_lift_m]
+        for name, pose in (("LIFT", lift), ("ABOVE_HIGH", above_high), ("ABOVE_PALM", above_palm),
+                           ("RELEASE", release), ("RETREAT", retreat)):
+            print(f"[PLAN] {name}: xyz_m=[{pose[0]:.3f}, {pose[1]:.3f}, {pose[2]:.3f}]")
+        print(
+            "[PLAN] descent ABOVE_PALM -> RELEASE in "
+            f"{math.ceil((above_palm[2] - release[2]) / max(args.descent_step_m, 0.005))} steps of "
+            f"{args.descent_step_m * 1000.0:.0f}mm with force abort delta {args.force_abort_delta_n:.1f}N"
+        )
+        if not args.execute:
+            return 0
+
+        # --- GATED EXECUTION ---
+        require_typed_approval(
+            MOTION_APPROVAL_PHRASE,
+            prompt=(
+                "[Azas] HRI MOTION APPROVAL REQUIRED. Confirm ALL:\n"
+                "  - e-stop within reach\n"
+                "  - only the receiving person is near the robot, arm steady, palm open\n"
+                "  - first run was validated on a foam block, not a person\n"
+                "  - speeds/bounds above were reviewed"
+            ),
+            preapproved=args.approve_motion,
+        )
+        run_movel(args, lift, label="LIFT to transit height (Z-only)",
+                  velocity=args.transit_velocity, acceleration=args.transit_acceleration)
+        run_movel(args, above_high, label="ABOVE_HIGH over palm at transit height",
+                  velocity=args.transit_velocity, acceleration=args.transit_acceleration)
+        run_movel(args, above_palm, label="ABOVE_PALM vertical pre-descent",
+                  velocity=args.descent_velocity, acceleration=args.descent_acceleration)
+
+        # Hand must still be where we planned; people move.
+        recheck = perception.sample_palm_base(label="palm re-check before descent")
+        moved = math.dist(recheck, palm)
+        if moved > args.hand_recheck_tolerance_m:
+            print(f"[ABORT] palm moved {moved * 1000.0:.0f}mm since planning; retreating without descent")
+            run_movel(args, retreat, label="RETREAT after palm moved",
+                      velocity=args.transit_velocity, acceleration=args.transit_acceleration)
+            return 1
+
+        baseline = perception.tool_force_n()
+        baseline_mag = math.sqrt(sum(v * v for v in baseline))
+        z = above_palm[2]
+        while z > release[2] + 1e-6:
+            z = max(z - max(args.descent_step_m, 0.005), release[2])
+            run_movel(args, [palm[0], palm[1], z], label=f"descent step to z={z:.3f}m",
+                      velocity=args.descent_velocity, acceleration=args.descent_acceleration)
+            force = perception.tool_force_n()
+            force_mag = math.sqrt(sum(v * v for v in force))
+            print(f"[Azas] tool force {force_mag:.1f}N (baseline {baseline_mag:.1f}N)")
+            if force_mag - baseline_mag > args.force_abort_delta_n:
+                print("[ABORT] force spike during descent (palm contact or obstruction); retreating with cup")
+                run_movel(args, retreat, label="RETREAT after force abort",
+                          velocity=args.transit_velocity, acceleration=args.transit_acceleration)
+                return 1
+
+        if not args.auto_release:
+            require_typed_approval(
+                RELEASE_APPROVAL_PHRASE,
+                prompt="[Azas] Cup is at release height. Confirm the palm is directly under the cup.",
+                preapproved=args.approve_release,
+            )
+        open_gripper(args)
+        time.sleep(1.0)
+        run_movel(args, retreat, label="RETREAT vertical after release",
+                  velocity=args.transit_velocity, acceleration=args.transit_acceleration)
+        print("[PASS] palm handover sequence completed")
+        return 0
+    except RuntimeError as exc:
+        print(f"[FAIL] {exc}")
+        return 1
+    finally:
+        perception.close()
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/tools/run/place_side_grip_cup_in_holder.py b/tools/run/place_side_grip_cup_in_holder.py
index ce99e79..75a6aa2 100755
--- a/tools/run/place_side_grip_cup_in_holder.py
+++ b/tools/run/place_side_grip_cup_in_holder.py
@@ -87,6 +87,12 @@ def offset_target_z(target: TargetPose, offset_m: float) -> TargetPose:
     return TargetPose(target.label, adjusted_xyz, list(target.rpy_rad))
 
 
+def offset_target_y(target: TargetPose, offset_m: float) -> TargetPose:
+    adjusted_xyz = list(target.xyz_m)
+    adjusted_xyz[1] += float(offset_m)
+    return TargetPose(target.label, adjusted_xyz, list(target.rpy_rad))
+
+
 def print_target(target: TargetPose) -> None:
     rx, ry, rz = target.rpy_deg
     x, y, z = target.xyz_m
@@ -275,11 +281,11 @@ def parse_args() -> argparse.Namespace:
     )
     parser.add_argument("--config", type=Path, default=DEFAULT_CONFIG)
     parser.add_argument("--service-prefix", default="dsr01")
-    parser.add_argument("--approach-velocity", type=float, default=15.0)
+    parser.add_argument("--approach-velocity", type=float, default=80.0)
     parser.add_argument("--approach-acceleration", type=float, default=20.0)
-    parser.add_argument("--place-velocity", type=float, default=6.0)
+    parser.add_argument("--place-velocity", type=float, default=80.0)
     parser.add_argument("--place-acceleration", type=float, default=10.0)
-    parser.add_argument("--retreat-velocity", type=float, default=12.0)
+    parser.add_argument("--retreat-velocity", type=float, default=80.0)
     parser.add_argument("--retreat-acceleration", type=float, default=16.0)
     parser.add_argument(
         "--place-final-z-offset-m",
@@ -290,6 +296,15 @@ def parse_args() -> argparse.Namespace:
             "to lower the cup into the holder without rewriting calibration.yaml."
         ),
     )
+    parser.add_argument(
+        "--place-final-y-offset-m",
+        type=float,
+        default=-0.010,
+        help=(
+            "Measured adjustment added only to place_final Y. Default -0.010m shifts "
+            "the holder placement 10mm in negative Y without rewriting calibration.yaml."
+        ),
+    )
     parser.add_argument("--timeout-sec", type=float, default=90.0)
     parser.add_argument("--wait-service-sec", type=float, default=8.0)
     parser.add_argument("--verify-timeout-sec", type=float, default=35.0)
@@ -343,6 +358,8 @@ def main() -> int:
 
     try:
         pre_place, place_final, retreat, approach_lift_m = load_sequence(args.config)
+        if abs(args.place_final_y_offset_m) > 1e-9:
+            place_final = offset_target_y(place_final, args.place_final_y_offset_m)
         if abs(args.place_final_z_offset_m) > 1e-9:
             place_final = offset_target_z(place_final, args.place_final_z_offset_m)
     except (OSError, ValueError, yaml.YAMLError) as exc:
@@ -353,6 +370,7 @@ def main() -> int:
     print(f"[Azas] config={args.config}")
     print(f"[Azas] service_prefix={args.service_prefix}")
     print(f"[Azas] approach_lift_m={approach_lift_m:.3f}")
+    print(f"[Azas] place_final_y_offset_m={args.place_final_y_offset_m:.4f}")
     print(f"[Azas] place_final_z_offset_m={args.place_final_z_offset_m:.4f}")
     print_target(pre_place)
     print_target(place_final)
diff --git a/tools/run/preview_measured_dispenser_recipe_rviz.py b/tools/run/preview_measured_dispenser_recipe_rviz.py
new file mode 100755
index 0000000..9c5814f
--- /dev/null
+++ b/tools/run/preview_measured_dispenser_recipe_rviz.py
@@ -0,0 +1,574 @@
+#!/usr/bin/env python3
+"""RViz-only preview of measured cocktail dispenser recipe joints.
+
+This script reads joint teaching values from calibration.yaml and publishes only
+sensor_msgs/JointState so RViz can animate the M0609 RobotModel in sequence.
+It never calls real robot services, MoveJoint, MoveLine, gripper services, or
+MoveIt execution.  SAFE_LIFT and PRESS_Z_OVERDRIVE_40MM are logged as real-code
+TCP linear motions, but this preview holds the measured joint pose for safety.
+"""
+
+from __future__ import annotations
+
+import argparse
+import math
+from dataclasses import dataclass
+from pathlib import Path
+
+import rclpy
+import yaml
+from rclpy.executors import ExternalShutdownException
+from rclpy.node import Node
+from sensor_msgs.msg import JointState
+from visualization_msgs.msg import Marker, MarkerArray
+
+DEFAULT_CALIBRATION = Path("/home/ssu/Azas/src/azas_bringup/config/calibration.yaml")
+DEFAULT_JOINT_NAMES = "joint_1,joint_2,joint_3,joint_4,joint_5,joint_6"
+ALLOWED_DISPENSER_IDS = {"1", "2", "3", "4"}
+JOINT_COUNT = 6
+DEFAULT_JOINT_VELOCITY_DEG_S = 40.0
+DEFAULT_PRESS_DEPTH_M = 0.040
+
+STAGES = (
+    "DISP_PRE",
+    "DISP_PLACE",
+    "RELEASE",
+    "SAFE_LIFT",
+    "PRESS_PRE",
+    "PRESS_CONTACT",
+    "PRESS_Z_OVERDRIVE",
+    "PRESS_CONTACT_RETURN",
+    "PRESS_PRE_RETURN",
+    "DISP_PRE_REGRASP",
+    "DISP_PLACE_REGRASP",
+)
+
+
+def log(message: str) -> None:
+    print(message, flush=True)
+
+
+@dataclass(frozen=True)
+class Waypoint:
+    order: int
+    dispenser_id: str
+    stage: str
+    joints_deg: list[float]
+    note: str = ""
+    taught_joints_deg: list[float] | None = None
+
+    @property
+    def source_joints_deg(self) -> list[float]:
+        return self.taught_joints_deg if self.taught_joints_deg is not None else self.joints_deg
+
+
+def parse_dispenser_ids(raw: str) -> list[str]:
+    values: list[str] = []
+    for part in raw.replace(";", ",").split(","):
+        item = part.strip().lower()
+        if not item:
+            continue
+        if "x" in item:
+            dispenser_id, count_raw = item.split("x", 1)
+        elif ":" in item:
+            dispenser_id, count_raw = item.split(":", 1)
+        else:
+            dispenser_id, count_raw = item, "1"
+        dispenser_id = dispenser_id.strip()
+        try:
+            count = int(count_raw.strip())
+        except ValueError as exc:
+            raise ValueError(f"invalid count for dispenser {dispenser_id}: {count_raw!r}") from exc
+        if count < 1:
+            raise ValueError(f"count must be >= 1 for dispenser {dispenser_id}")
+        values.extend([dispenser_id] * count)
+
+    if not values:
+        raise ValueError("at least one dispenser id is required")
+
+    invalid = [value for value in values if value not in ALLOWED_DISPENSER_IDS]
+    if invalid:
+        allowed = ",".join(sorted(ALLOWED_DISPENSER_IDS))
+        raise ValueError(f"unsupported dispenser id(s): {', '.join(invalid)}; allowed: {allowed}")
+    return values
+
+
+def parse_joint_names(raw: str) -> list[str]:
+    names = [item.strip() for item in raw.split(",") if item.strip()]
+    if len(names) != JOINT_COUNT:
+        raise ValueError(f"--joint-names must provide exactly {JOINT_COUNT} names")
+    return names
+
+
+def parse_joint_index_set(raw: str) -> set[int]:
+    indexes: set[int] = set()
+    for part in raw.replace(";", ",").split(","):
+        item = part.strip().lower()
+        if not item:
+            continue
+        if item.startswith("joint_"):
+            item = item[6:]
+        elif item.startswith("j"):
+            item = item[1:]
+        try:
+            index = int(item)
+        except ValueError as exc:
+            raise ValueError(f"--press-lock-contact-joints contains a non-joint value: {part!r}") from exc
+        if not 1 <= index <= JOINT_COUNT:
+            raise ValueError(f"--press-lock-contact-joints joint index must be 1..{JOINT_COUNT}, got {part!r}")
+        indexes.add(index - 1)
+    return indexes
+
+
+def read_yaml(path: Path) -> dict:
+    data = yaml.safe_load(path.read_text(encoding="utf-8")) or {}
+    if not isinstance(data, dict):
+        raise ValueError(f"YAML root must be a map: {path}")
+    return data
+
+
+def numeric_joints(raw: object, label: str) -> list[float]:
+    if not isinstance(raw, list) or len(raw) != JOINT_COUNT:
+        raise ValueError(f"{label} must be a {JOINT_COUNT}-item list")
+    try:
+        return [float(value) for value in raw]
+    except (TypeError, ValueError) as exc:
+        raise ValueError(f"{label} must contain numeric degree values") from exc
+
+
+def load_outlet_joints(calibration: dict, dispenser_id: str) -> dict[str, list[float]]:
+    outlets = calibration.get("dispenser_outlets")
+    if not isinstance(outlets, dict):
+        raise ValueError("calibration.yaml is missing dispenser_outlets")
+
+    outlet = outlets.get(dispenser_id)
+    if not isinstance(outlet, dict):
+        raise ValueError(f"dispenser_outlets.{dispenser_id} is missing")
+
+    required_fields = (
+        "cup_pre_place_joints_deg",
+        "cup_place_joints_deg",
+        "press_pre_joints_deg",
+        "press_contact_joints_deg",
+    )
+    joints: dict[str, list[float]] = {}
+    for field in required_fields:
+        joints[field] = numeric_joints(
+            outlet.get(field),
+            f"dispenser_outlets.{dispenser_id}.{field}",
+        )
+    return joints
+
+
+def lock_contact_joints_to_pre(
+    press_contact: list[float],
+    press_pre: list[float],
+    locked_joint_indexes: set[int],
+) -> tuple[list[float], str]:
+    if not locked_joint_indexes:
+        return list(press_contact), ""
+    locked = list(press_contact)
+    labels: list[str] = []
+    for index in sorted(locked_joint_indexes):
+        original = locked[index]
+        locked[index] = press_pre[index]
+        labels.append(f"joint_{index + 1} {original:.2f}->{locked[index]:.2f}")
+    return locked, "press-lock-contact-joints: " + ", ".join(labels)
+
+
+def build_waypoints(
+    calibration: dict,
+    dispenser_ids: list[str],
+    locked_press_contact_joints: set[int],
+    press_overdrive_mm: float,
+) -> list[Waypoint]:
+    waypoints: list[Waypoint] = []
+    for order, dispenser_id in enumerate(dispenser_ids, start=1):
+        joints = load_outlet_joints(calibration, dispenser_id)
+        cup_pre = joints["cup_pre_place_joints_deg"]
+        cup_place = joints["cup_place_joints_deg"]
+        press_pre = joints["press_pre_joints_deg"]
+        press_contact, press_contact_note = lock_contact_joints_to_pre(
+            joints["press_contact_joints_deg"],
+            press_pre,
+            locked_press_contact_joints,
+        )
+
+        waypoints.extend(
+            [
+                Waypoint(order, dispenser_id, "DISP_PRE", cup_pre),
+                Waypoint(order, dispenser_id, "DISP_PLACE", cup_place),
+                Waypoint(order, dispenser_id, "RELEASE", cup_place, "preview holds DISP_PLACE"),
+                Waypoint(
+                    order,
+                    dispenser_id,
+                    "SAFE_LIFT",
+                    cup_place,
+                    "real code has safe_lift_current TCP MoveLine; preview holds DISP_PLACE",
+                ),
+                Waypoint(order, dispenser_id, "PRESS_PRE", press_pre),
+                Waypoint(order, dispenser_id, "PRESS_CONTACT", press_contact, press_contact_note),
+                # TODO: replace this hold with a preview-only FK/IK joint state for
+                # the 40 mm TCP-Z overdrive once a non-hardware kinematics path is
+                # available.
+                Waypoint(
+                    order,
+                    dispenser_id,
+                    f"PRESS_Z_OVERDRIVE_{press_overdrive_mm:.0f}MM",
+                    press_contact,
+                    (
+                        f"real code uses TCP Z MoveLine {press_overdrive_mm:.1f}mm; "
+                        "preview holds PRESS_CONTACT"
+                    ),
+                ),
+                Waypoint(order, dispenser_id, "PRESS_CONTACT_RETURN", press_contact),
+                Waypoint(order, dispenser_id, "PRESS_PRE_RETURN", press_pre),
+                Waypoint(order, dispenser_id, "DISP_PRE_REGRASP", cup_pre),
+                Waypoint(order, dispenser_id, "DISP_PLACE_REGRASP", cup_place),
+            ]
+        )
+    return waypoints
+
+
+def nearest_equivalent_deg(target: float, current: float) -> float:
+    candidates = [target + 360.0 * offset for offset in range(-2, 3)]
+    bounded = [candidate for candidate in candidates if abs(candidate) <= 360.0]
+    if bounded:
+        candidates = bounded
+    return min(candidates, key=lambda candidate: abs(candidate - current))
+
+
+def unwrap_waypoints(waypoints: list[Waypoint]) -> list[Waypoint]:
+    if not waypoints:
+        return []
+
+    unwrapped: list[Waypoint] = []
+    previous = waypoints[0].joints_deg
+    unwrapped.append(waypoints[0])
+    for waypoint in waypoints[1:]:
+        adjusted = [
+            nearest_equivalent_deg(target, current)
+            for target, current in zip(waypoint.joints_deg, previous)
+        ]
+        previous = adjusted
+        unwrapped.append(
+            Waypoint(
+                order=waypoint.order,
+                dispenser_id=waypoint.dispenser_id,
+                stage=waypoint.stage,
+                joints_deg=adjusted,
+                note=waypoint.note,
+                taught_joints_deg=waypoint.joints_deg,
+            )
+        )
+    return unwrapped
+
+
+def interpolate_deg(start: list[float], end: list[float], ratio: float) -> list[float]:
+    ratio = max(0.0, min(1.0, ratio))
+    return [a + (b - a) * ratio for a, b in zip(start, end)]
+
+
+def format_joints(values: list[float]) -> str:
+    return "[" + ", ".join(f"{value:.2f}" for value in values) + "]"
+
+
+class JointStatePreviewNode(Node):
+    def __init__(
+        self,
+        waypoints: list[Waypoint],
+        joint_names: list[str],
+        joint_topic: str,
+        marker_topic: str,
+        rate_hz: float,
+        segment_seconds: float,
+        joint_velocity_deg_s: float,
+        hold_seconds: float,
+        loop: bool,
+    ) -> None:
+        super().__init__("preview_measured_dispenser_recipe_rviz")
+        self._publisher = self.create_publisher(JointState, joint_topic, 10)
+        self._marker_publisher = self.create_publisher(MarkerArray, marker_topic, 10) if marker_topic else None
+        self._waypoints = waypoints
+        self._joint_names = joint_names
+        self._marker_topic = marker_topic
+        self._loop = loop
+        self._rate_hz = rate_hz
+        self._segment_seconds = segment_seconds
+        self._joint_velocity_deg_s = joint_velocity_deg_s
+        self._segment_frames = self._segment_frame_count(0, loop_to_start=False)
+        self._hold_frames = max(1, int(round(hold_seconds * rate_hz)))
+        self._index = 0
+        self._phase = "hold"
+        self._phase_frame = 0
+        self._looping_to_start = False
+        self._announced_current = False
+        self._done = False
+        self._timer = self.create_timer(1.0 / rate_hz, self._tick)
+
+        log("[Azas] RViz-only measured dispenser recipe preview")
+        log("[Azas] publishing JointState only; service_calls=none")
+        log("[Azas] this process does not open RViz; use tools/run/show_measured_recipe_joint_preview_rviz.sh to open RViz too")
+        log(f"[Azas] joint_topic={joint_topic}")
+        if marker_topic:
+            log(f"[Azas] marker_topic={marker_topic}")
+        log(f"[Azas] joint_names={','.join(joint_names)}")
+        if joint_velocity_deg_s > 0.0:
+            log(f"[Azas] preview_joint_velocity_deg_s={joint_velocity_deg_s:.2f}")
+        else:
+            log(f"[Azas] preview_fixed_segment_seconds={segment_seconds:.2f}")
+        log(
+            "[Azas] sequence="
+            + " -> ".join(STAGES)
+        )
+
+    @property
+    def done(self) -> bool:
+        return self._done
+
+    def _tick(self) -> None:
+        if self._phase == "hold":
+            waypoint = self._waypoints[self._index]
+            if not self._announced_current:
+                self._announce_stage(waypoint)
+                self._announced_current = True
+            self._publish(waypoint.joints_deg)
+            self._phase_frame += 1
+            if self._phase_frame >= self._hold_frames:
+                self._phase_frame = 0
+                if self._index >= len(self._waypoints) - 1:
+                    if self._loop:
+                        self._phase = "segment"
+                        self._looping_to_start = True
+                        self._segment_frames = self._segment_frame_count(self._index, loop_to_start=True)
+                    else:
+                        log("[Azas] preview_complete")
+                        self._done = True
+                        self._timer.cancel()
+                else:
+                    self._phase = "segment"
+                    self._segment_frames = self._segment_frame_count(self._index, loop_to_start=False)
+            return
+
+        target_index = 0 if self._looping_to_start else self._index + 1
+        start = self._waypoints[self._index].joints_deg
+        end = self._waypoints[target_index].joints_deg
+        ratio = (self._phase_frame + 1) / self._segment_frames
+        self._publish(interpolate_deg(start, end, ratio))
+        self._phase_frame += 1
+        if self._phase_frame >= self._segment_frames:
+            self._index = target_index
+            self._phase = "hold"
+            self._phase_frame = 0
+            self._looping_to_start = False
+            self._announced_current = False
+
+    def _segment_frame_count(self, start_index: int, *, loop_to_start: bool) -> int:
+        if self._joint_velocity_deg_s <= 0.0:
+            seconds = self._segment_seconds
+        else:
+            target_index = 0 if loop_to_start else min(start_index + 1, len(self._waypoints) - 1)
+            start = self._waypoints[start_index].joints_deg
+            end = self._waypoints[target_index].joints_deg
+            max_delta_deg = max(abs(a - b) for a, b in zip(start, end))
+            seconds = max_delta_deg / self._joint_velocity_deg_s if max_delta_deg > 0.0 else 0.0
+            seconds = max(seconds, 1.0 / self._rate_hz)
+        return max(1, int(math.ceil(seconds * self._rate_hz)))
+
+    def _announce_stage(self, waypoint: Waypoint) -> None:
+        source = waypoint.source_joints_deg
+        published = waypoint.joints_deg
+        suffix = ""
+        if any(abs(a - b) > 1e-6 for a, b in zip(source, published)):
+            suffix = f" publish_joint_deg={format_joints(published)}"
+        log(
+            f"[Azas] dispenser={waypoint.dispenser_id} "
+            f"cycle={waypoint.order} stage={waypoint.stage} "
+            f"joint_deg={format_joints(source)}{suffix}"
+        )
+        if waypoint.note:
+            log(f"[Azas] {waypoint.stage} note={waypoint.note}")
+        self._publish_stage_marker(waypoint)
+
+    def _publish(self, joints_deg: list[float]) -> None:
+        msg = JointState()
+        msg.header.stamp = self.get_clock().now().to_msg()
+        msg.name = self._joint_names
+        msg.position = [math.radians(value) for value in joints_deg]
+        self._publisher.publish(msg)
+
+    def _publish_stage_marker(self, waypoint: Waypoint) -> None:
+        if self._marker_publisher is None:
+            return
+        marker = Marker()
+        marker.header.frame_id = "base_link"
+        marker.header.stamp = self.get_clock().now().to_msg()
+        marker.ns = "measured_joint_preview_stage"
+        marker.id = 1
+        marker.type = Marker.TEXT_VIEW_FACING
+        marker.action = Marker.ADD
+        marker.pose.position.x = 0.42
+        marker.pose.position.y = -0.42
+        marker.pose.position.z = 0.72
+        marker.pose.orientation.w = 1.0
+        marker.scale.z = 0.055
+        marker.color.r = 0.92
+        marker.color.g = 0.96
+        marker.color.b = 1.0
+        marker.color.a = 1.0
+        marker.text = f"D{waypoint.dispenser_id} cycle {waypoint.order}\\n{waypoint.stage}"
+        if waypoint.note:
+            marker.text += f"\\n{waypoint.note}"
+        marker_array = MarkerArray()
+        marker_array.markers.append(marker)
+        self._marker_publisher.publish(marker_array)
+
+
+def positive_float(value: str) -> float:
+    parsed = float(value)
+    if parsed <= 0.0:
+        raise argparse.ArgumentTypeError("must be > 0")
+    return parsed
+
+
+def nonnegative_float(value: str) -> float:
+    parsed = float(value)
+    if parsed < 0.0:
+        raise argparse.ArgumentTypeError("must be >= 0")
+    return parsed
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description=(
+            "Publish measured dispenser recipe joints as JointState for RViz only. "
+            "No robot, gripper, MoveIt execution, MoveJoint, or MoveLine service is called."
+        )
+    )
+    parser.add_argument(
+        "--dispenser-ids",
+        default="1",
+        help="Physical dispenser sequence. Supports values like 1,2,3,4 or 1x2,3.",
+    )
+    parser.add_argument(
+        "--calibration",
+        type=Path,
+        default=DEFAULT_CALIBRATION,
+        help=f"Path to calibration.yaml (default: {DEFAULT_CALIBRATION})",
+    )
+    parser.add_argument(
+        "--rate-hz",
+        "--publish-rate-hz",
+        dest="rate_hz",
+        type=positive_float,
+        default=30.0,
+    )
+    parser.add_argument("--segment-seconds", type=positive_float, default=2.0)
+    parser.add_argument(
+        "--joint-velocity-deg-s",
+        type=nonnegative_float,
+        default=DEFAULT_JOINT_VELOCITY_DEG_S,
+        help=(
+            "Preview interpolation speed in deg/s. Default 40. Set 0 to use "
+            "--segment-seconds as a fixed duration for every waypoint transition."
+        ),
+    )
+    parser.add_argument("--hold-seconds", type=nonnegative_float, default=1.0)
+    parser.add_argument(
+        "--press-lock-contact-joints",
+        default="",
+        help=(
+            "Compatibility with real recipe commands: comma-separated joint numbers "
+            "copied from PRESS_PRE into PRESS_CONTACT for preview, e.g. 6."
+        ),
+    )
+    parser.add_argument("--press-depth-m", type=nonnegative_float, default=DEFAULT_PRESS_DEPTH_M)
+    parser.add_argument("--press-extra-depth-m", type=nonnegative_float, default=0.0)
+    parser.add_argument(
+        "--press-use-recorded-pre-joints",
+        action=argparse.BooleanOptionalAction,
+        default=True,
+        help="Compatibility no-op: preview always uses calibration.yaml press_pre_joints_deg.",
+    )
+    parser.add_argument(
+        "--press-reset-before-press",
+        action=argparse.BooleanOptionalAction,
+        default=False,
+        help="Compatibility no-op: preview never inserts the reset joint pose.",
+    )
+    parser.add_argument(
+        "--safe-lift-joint-fallback",
+        action=argparse.BooleanOptionalAction,
+        default=True,
+        help="Compatibility no-op: preview logs SAFE_LIFT but does not call IK/MoveJoint.",
+    )
+    parser.add_argument(
+        "--unwrap-joints",
+        action=argparse.BooleanOptionalAction,
+        default=True,
+        help="Use nearest equivalent joint angles for smooth RViz interpolation across +/-180/360 boundaries.",
+    )
+    loop_group = parser.add_mutually_exclusive_group()
+    loop_group.add_argument("--loop", dest="loop", action="store_true", help="Repeat the preview until interrupted.")
+    loop_group.add_argument("--no-loop", dest="loop", action="store_false", help="Play once and exit.")
+    parser.set_defaults(loop=False)
+    parser.add_argument("--joint-topic", "--joint-state-topic", dest="joint_topic", default="/joint_states")
+    parser.add_argument("--marker-topic", default="/azas/measured_joint_preview/markers")
+    parser.add_argument("--joint-names", default=DEFAULT_JOINT_NAMES)
+    args, unknown = parser.parse_known_args()
+    args.ignored_real_motion_args = unknown
+    return args
+
+
+def main() -> int:
+    args = parse_args()
+    try:
+        dispenser_ids = parse_dispenser_ids(args.dispenser_ids)
+        joint_names = parse_joint_names(args.joint_names)
+        locked_press_contact_joints = parse_joint_index_set(args.press_lock_contact_joints)
+        press_overdrive_mm = (args.press_depth_m + args.press_extra_depth_m) * 1000.0
+        calibration = read_yaml(args.calibration)
+        waypoints = build_waypoints(
+            calibration,
+            dispenser_ids,
+            locked_press_contact_joints,
+            press_overdrive_mm,
+        )
+        if args.unwrap_joints:
+            waypoints = unwrap_waypoints(waypoints)
+    except (OSError, ValueError) as exc:
+        log(f"[Azas] preview setup failed: {exc}")
+        return 2
+
+    if not waypoints:
+        log("[Azas] preview setup failed: no waypoints")
+        return 2
+
+    rclpy.init()
+    node = JointStatePreviewNode(
+        waypoints=waypoints,
+        joint_names=joint_names,
+        joint_topic=args.joint_topic,
+        marker_topic=args.marker_topic,
+        rate_hz=args.rate_hz,
+        segment_seconds=args.segment_seconds,
+        joint_velocity_deg_s=args.joint_velocity_deg_s,
+        hold_seconds=args.hold_seconds,
+        loop=args.loop,
+    )
+    if args.ignored_real_motion_args:
+        log("[Azas] ignored_real_motion_args=" + " ".join(args.ignored_real_motion_args))
+    try:
+        while rclpy.ok() and not node.done:
+            rclpy.spin_once(node, timeout_sec=0.1)
+    except (KeyboardInterrupt, ExternalShutdownException):
+        pass
+    finally:
+        node.destroy_node()
+        if rclpy.ok():
+            rclpy.shutdown()
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/tools/run/record_dispenser_press_pose.py b/tools/run/record_dispenser_press_pose.py
index 22b8d55..d0f8390 100644
--- a/tools/run/record_dispenser_press_pose.py
+++ b/tools/run/record_dispenser_press_pose.py
@@ -130,6 +130,45 @@ def update_config(config_path: Path, dispenser_id: str, kind: str, posx: list[fl
             format_list(posj, 2),
             measured_comment,
         )
+    elif kind == "common_pre":
+        text = replace_block_value(
+            text,
+            dispenser_id,
+            "press_common_pre_joints_deg",
+            format_list(posj, 2),
+            measured_comment,
+        )
+    elif kind == "cup_common_pre":
+        text = replace_block_value(
+            text,
+            dispenser_id,
+            "cup_common_pre_joints_deg",
+            format_list(posj, 2),
+            measured_comment,
+        )
+    elif kind == "cup_pre":
+        text = replace_block_value(
+            text,
+            dispenser_id,
+            "cup_pre_place_joints_deg",
+            format_list(posj, 2),
+            measured_comment,
+        )
+    elif kind == "cup_place":
+        text = replace_block_value(
+            text,
+            dispenser_id,
+            "cup_place_joints_deg",
+            format_list(posj, 2),
+            measured_comment,
+        )
+        text = replace_block_value(
+            text,
+            dispenser_id,
+            "cup_place_status",
+            "measured_confirmed",
+            measured_comment,
+        )
     else:
         raise RuntimeError(f"unsupported kind: {kind}")
 
@@ -137,10 +176,49 @@ def update_config(config_path: Path, dispenser_id: str, kind: str, posx: list[fl
     return backup_path
 
 
+def warn_lane_mismatch(dispenser_id: str, kind: str, posx: list[float], tolerance_mm: float = 25.0) -> None:
+    """Warn when the recorded pose sits laterally over a different dispenser lane.
+
+    Guards against the slot mix-ups observed on 2026-06-10 where press teach
+    poses were saved under neighboring dispenser ids. Warning only; the
+    operator decides.
+    """
+    collision_config = ROOT / "src" / "azas_bringup" / "config" / "measured_dispenser_collision.yaml"
+    try:
+        import yaml
+
+        data = yaml.safe_load(collision_config.read_text(encoding="utf-8")) or {}
+        front_holds = data.get("front_hold_poses") or {}
+        lane_y_mm = {
+            key.split("_")[-1]: float(value["position_xyz_m"][1]) * 1000.0
+            for key, value in front_holds.items()
+        }
+    except Exception:
+        return
+    expected = lane_y_mm.get(dispenser_id)
+    if expected is None:
+        return
+    actual = posx[1]
+    delta = actual - expected
+    nearest = min(lane_y_mm.items(), key=lambda kv: abs(kv[1] - actual))
+    if abs(delta) > tolerance_mm:
+        print(
+            f"[WARN] {kind} y={actual:.1f}mm is {abs(delta):.0f}mm away from dispenser "
+            f"{dispenser_id} lane (expected y~{expected:.1f}mm); nearest lane is "
+            f"dispenser {nearest[0]}. Check the dispenser id before trusting this record."
+        )
+    else:
+        print(f"[Azas] lane check OK: y={actual:.1f}mm matches dispenser {dispenser_id} (expected ~{expected:.1f}mm)")
+
+
 def main() -> int:
     parser = argparse.ArgumentParser()
     parser.add_argument("--dispenser-id", required=True, choices=["1", "2", "3", "4"])
-    parser.add_argument("--kind", required=True, choices=["pre", "contact"])
+    parser.add_argument(
+        "--kind",
+        required=True,
+        choices=["pre", "common_pre", "contact", "cup_common_pre", "cup_pre", "cup_place"],
+    )
     parser.add_argument("--service-prefix", default="dsr01")
     parser.add_argument("--config", type=Path, default=DEFAULT_CONFIG)
     parser.add_argument("--timeout-sec", type=float, default=8.0)
@@ -167,8 +245,17 @@ def main() -> int:
         print(f"[Azas] calibration press_pose_xyz_m={format_list([value / 1000.0 for value in posx[:3]], 6)}")
         print(f"[Azas] calibration press_pose_rpy_deg={format_list(posx[3:6], 3)}")
         print(f"[Azas] calibration press_contact_joints_deg={format_list(posj, 2)}")
-    else:
+    elif args.kind == "pre":
         print(f"[Azas] calibration press_pre_joints_deg={format_list(posj, 2)}")
+    elif args.kind == "common_pre":
+        print(f"[Azas] calibration press_common_pre_joints_deg={format_list(posj, 2)}")
+    elif args.kind == "cup_common_pre":
+        print(f"[Azas] calibration cup_common_pre_joints_deg={format_list(posj, 2)}")
+    elif args.kind == "cup_pre":
+        print(f"[Azas] calibration cup_pre_place_joints_deg={format_list(posj, 2)}")
+    else:
+        print(f"[Azas] calibration cup_place_joints_deg={format_list(posj, 2)}")
+    warn_lane_mismatch(args.dispenser_id, args.kind, posx)
 
     backup_path = update_config(args.config, args.dispenser_id, args.kind, posx, posj)
     print(f"[PASS] updated {args.config}")
diff --git a/tools/run/robot_pipeline_control_server.py b/tools/run/robot_pipeline_control_server.py
index 4492c86..81c3239 100755
--- a/tools/run/robot_pipeline_control_server.py
+++ b/tools/run/robot_pipeline_control_server.py
@@ -312,7 +312,7 @@ def _color_recipe_direct_arg(payload: dict[str, Any]) -> str:
     )
     if numeric_dispenser_override:
         return f" --dispenser-ids {shlex.quote(recipe_override)}"
-    direct_color_map = json.dumps(DISPENSER_PRESS_TARGETS, ensure_ascii=False)
+    direct_color_map = json.dumps(_load_dispenser_press_targets(), ensure_ascii=False)
     return (
         f" --colors {shlex.quote(recipe_override)}"
         f" --color-map-json {shlex.quote(direct_color_map)}"
@@ -322,7 +322,7 @@ def _color_recipe_direct_arg(payload: dict[str, Any]) -> str:
 def color_recipe_sequence_command(payload: dict[str, Any]) -> str:
     return (
         f"cd {ROOT} && {ROS_SETUP} && "
-        "python3 tools/run/run_color_recipe_sequence.py --press-depth-m 0.020 --execute --confirm"
+        "python3 tools/run/run_color_recipe_sequence.py --execute --confirm"
         f"{_color_recipe_direct_arg(payload)}"
     )
 
@@ -333,7 +333,8 @@ def chain_recipe_after_manual_command(manual_cmd: str, payload: dict[str, Any],
         f"( {manual_cmd} ); "
         "manual_rc=$?; "
         "if [ ${manual_rc} -eq 0 ]; then "
-        f"echo '[Azas] {label} 성공 종료 -> 통합 디스펜서 색상 레시피를 즉시 실행합니다.'; "
+        f"echo '[Azas] {label} 성공 메시지 확인 -> 통합 디스펜서 색상 레시피를 자동 실행합니다.'; "
+        "echo '[Azas] auto_integrated_dispenser_recipe=true'; "
         f"{recipe_cmd}; "
         "else "
         f"echo '[Azas] {label} 실패/중단 rc='${{manual_rc}}' -> 디스펜서 레시피 실행을 건너뜁니다.'; "
@@ -342,6 +343,59 @@ def chain_recipe_after_manual_command(manual_cmd: str, payload: dict[str, Any],
     )
 
 
+def chain_shake_after_lid_command(lid_cmd: str, payload: dict[str, Any]) -> str:
+    """Run holder re-pick + shake immediately after ArUco lid close success.
+
+    The lid-grip launch is an OpenCV/manual ROS launch that stays alive after a
+    successful `p`-triggered sequence.  Waiting for the process to exit would
+    block the next motion indefinitely, so the panel chain watches the planner's
+    `/jarvis/lid_gripper/status` success event, terminates the lid preview
+    launch, then starts the existing measured cup-holder re-pick/shake command.
+    """
+
+    steps_by_key = {step.key: step for step in STEPS}
+    shake_cmd = command_for(steps_by_key["shake_closed_cup"], payload)
+    wait_script = ROOT / "tools" / "run" / "wait_for_lid_grip_status.py"
+    wait_cmd = (
+        f"cd {ROOT} && {ROS_SETUP} && "
+        f"python3 {shlex.quote(str(wait_script))} "
+        "--timeout-sec 900 --success-status motion_sequence_requested"
+    )
+    return (
+        f"( {lid_cmd} ) & "
+        "lid_pid=$!; "
+        f"( {wait_cmd} ) & "
+        "wait_pid=$!; "
+        "while true; do "
+        "if ! kill -0 ${wait_pid} 2>/dev/null; then "
+        "wait ${wait_pid}; wait_rc=$?; break; "
+        "fi; "
+        "if ! kill -0 ${lid_pid} 2>/dev/null; then "
+        "wait ${lid_pid}; lid_rc=$?; "
+        "sleep 1; "
+        "if ! kill -0 ${wait_pid} 2>/dev/null; then "
+        "wait ${wait_pid}; wait_rc=$?; break; "
+        "fi; "
+        "echo '[Azas] lid_grip_close launch exited before ArUco success status; shake chain blocked.'; "
+        "kill -TERM ${wait_pid} 2>/dev/null || true; "
+        "wait ${wait_pid} 2>/dev/null || true; "
+        "if [ ${lid_rc} -eq 0 ]; then exit 1; else exit ${lid_rc}; fi; "
+        "fi; "
+        "sleep 1; "
+        "done; "
+        "kill -TERM ${lid_pid} 2>/dev/null || true; "
+        "wait ${lid_pid} 2>/dev/null || true; "
+        "if [ ${wait_rc} -eq 0 ]; then "
+        "echo '[Azas] ArUco lid_grip_close 성공 status 확인 -> 컵홀더 컵 다시 잡기 후 쉐이킹으로 바로 넘어갑니다.'; "
+        "echo '[Azas] auto_holder_pick_then_shake=true'; "
+        f"{shake_cmd}; "
+        "else "
+        "echo '[Azas] ArUco lid_grip_close 실패/타임아웃 -> 컵홀더 재픽업/쉐이킹을 건너뜁니다.'; "
+        "exit ${wait_rc}; "
+        "fi"
+    )
+
+
 def hand_eye_static_tf_command(*, compose_timeout_sec: float = 30.0) -> str:
     """Start the measured hand-eye TF publisher without inventing camera poses."""
     return (
@@ -351,6 +405,33 @@ def hand_eye_static_tf_command(*, compose_timeout_sec: float = 30.0) -> str:
     )
 
 
+def tmux_stack_start_command(payload: dict[str, Any]) -> str:
+    robot_host = str(payload.get("robot_host") or os.environ.get("ROBOT_HOST") or DEFAULT_ROBOT_HOST)
+    robot_name = str(payload.get("robot_name") or os.environ.get("ROBOT_NAME") or "dsr01")
+    rt_host = str(payload.get("rt_host") or os.environ.get("RT_HOST") or DEFAULT_RT_HOST)
+    rg2_ip = str(payload.get("rg2_ip") or os.environ.get("RG2_IP") or "192.168.1.1")
+    ros_domain_id = str(
+        payload.get("ros_domain_id")
+        or os.environ.get("AZAS_PANEL_ROS_DOMAIN_ID")
+        or os.environ.get("ROS_DOMAIN_ID")
+        or DEFAULT_ROS_DOMAIN_ID
+    )
+    ros_localhost_only = str(os.environ.get("ROS_LOCALHOST_ONLY") or "0")
+    return (
+        f"cd {ROOT} && "
+        "bash tools/run/stop_azas_all.sh && "
+        "sleep 2 && "
+        f"SESSION={shlex.quote(PANEL_TMUX_SESSION)} "
+        f"ROS_DOMAIN_ID={shlex.quote(ros_domain_id)} "
+        f"ROS_LOCALHOST_ONLY={shlex.quote(ros_localhost_only)} "
+        f"ROBOT_HOST={shlex.quote(robot_host)} "
+        f"ROBOT_NAME={shlex.quote(robot_name)} "
+        f"RT_HOST={shlex.quote(rt_host)} "
+        f"RG2_IP={shlex.quote(rg2_ip)} "
+        "bash tools/run/start_azas_tmux_stack.sh"
+    )
+
+
 def dispenser_color_map_status() -> dict[str, Any]:
     """Read outputs/dispenser_color_map.json and derive physical dispenser order.
 
@@ -519,12 +600,12 @@ class Step:
 STEPS = [
     Step(
         "connect_robot",
-        "로봇 연결 / 스마트 재연결",
+        "로봇 연결 / tmux 통합 재연결",
         "background",
-        "tools/run/run_doosan_real_m0609.sh",
+        "tools/run/stop_azas_all.sh && sleep 2 && tools/run/start_azas_tmux_stack.sh",
         True,
         False,
-        "실제 로봇 real-mode bringup. 준비됨/시작중이면 유지하고, stale 상태일 때만 정리 후 시작",
+        "검증된 현장 명령으로 stop_azas_all 후 azas-logic tmux 스택을 시작",
     ),
     Step(
         "start_tmux_stack",
@@ -533,7 +614,7 @@ class Step:
         "tools/run/start_azas_tmux_stack.sh",
         True,
         False,
-        "검증된 tmux 방식으로 azas-logic 세션에 로봇, RG2 그리퍼, RealSense, joint relay를 분리 시작. status_check/개별 연결 큐를 반복하지 않음",
+        "검증된 tmux 방식으로 stop_azas_all 후 azas-logic 세션에 로봇, RG2 그리퍼, RealSense, joint relay를 분리 시작",
     ),
     Step(
         "stop_azas_all",
@@ -658,15 +739,15 @@ class Step:
         False,
         "카메라 화면의 visible colored handle blob을 직접 검출해 왼쪽→오른쪽을 디스펜서 1~4로 매핑하고 outputs/dispenser_color_map.json 저장. TF 투영은 보조 경로",
     ),
-    Step("voice_input", "음성 입력 (STT+LLM 노드 시작)", "background", "ros2 launch azas_voice azas_voice.launch.py", True, False, "STT → /stt_result → llm_recipe_mapper → /azas/voice/recipe_decision"),
+    Step("voice_input", "수빈 STT/주문 UI 시작", "background", "ros2 launch azas_voice azas_voice.launch.py", True, False, "voice screen(8090) + STT topic(/stt_result) → recipe mapper → conversation manager. 로봇 좌표/모션은 만들지 않음"),
     Step(
         "listen_stt_recipe",
-        "STT 레시피 수신 대기 (60초)",
+        "수빈 STT 레시피 확정 대기 (60초)",
         "run",
         "tools/run/listen_stt_recipe.py --timeout 60",
         True,
         False,
-        "사용자가 말하면 /azas/voice/recipe_decision 수신 → outputs/latest_recipe.json 저장",
+        "사용자가 메뉴를 말하고 '응'으로 확정하면 /azas/voice/confirmed_recipe_decision 수신 → outputs/latest_recipe.json 저장",
     ),
     Step(
         "run_color_recipe_sequence",
@@ -681,10 +762,10 @@ class Step:
         "side_grip",
         "PR #20 RealSense 컵 인식 후 side grip",
         "background",
-        "ros2 launch dsr_practice yolo_cup_pick_node.launch.py auto_pick:=false exit_after_pick:=false grasp_mode:=side moveit_controller_name:=/dsr01/dsr_moveit_controller",
+        "SIDE_TARGET_X_OFFSET_M=-0.020 bash tools/run/run_changhyun_side_grip_direct.sh",
         True,
         True,
-        "OpenCV 창에서 컵 확인 후 p 키로 side-grip 실행. 장기 실행 GUI 노드라 패널에서는 tmux 창으로 분리 실행",
+        "OpenCV 창에서 컵 확인 후 p 키로 side-grip 실행. 패널은 direct runner를 tmux로 띄우며 기본 X 보정은 -20mm",
     ),
     Step(
         "cup_uprighting",
@@ -859,7 +940,35 @@ class Step:
         False,
         "실제 로봇 미사용: 별도 ROS_DOMAIN_ID에서 쉐이킹 궤적/마커를 RViz로 표시",
     ),
-    Step("shake_closed_cup", "컵홀더 컵 다시 잡기 후 쉐이킹", "run", "tools/run/pick_from_cup_holder_side_grip.py && tools/run/run_rule_based_shake_real.sh", True, True, "시작 시 컵홀더에 놓인 닫힌 컵을 측정된 cup_holder.side_grip_place pose로 다시 side-grip 픽업한 뒤, J3 양수 고정 및 J4/J5/J6 트위스트 쉐이킹을 실행"),
+    Step("shake_closed_cup", "컵홀더 컵 다시 잡기 후 쉐이킹", "run", "tools/run/pick_from_cup_holder_side_grip.py && tools/run/run_rule_based_shake_real.sh", True, True, "시작 시 컵홀더에 놓인 닫힌 컵을 측정된 cup_holder.side_grip_place pose로 다시 side-grip 픽업한 뒤, J3 양수 고정 및 J4/J5/J6 트위스트 쉐이킹을 실행. 쉐이킹 성공 시 컵을 든 채 카메라 포즈(J=[3, -12.7, 44, -9, 133, 90])로 복귀해 손 검출/핸드오버 준비"),
+    Step(
+        "start_hand_detection",
+        "손 검출 시작 / 무모션",
+        "background",
+        "bash tools/run/run_human_hand_detection.sh",
+        True,
+        False,
+        "perception 전용: MediaPipe로 펼친 손바닥을 추적해 /azas/human_hand_detection으로 발행. 로봇 모션 없음",
+    ),
+    Step(
+        "start_hand_detection_view",
+        "손 검출 화면 보기",
+        "background",
+        "rqt_image_view /azas/human_hand_detection/overlay",
+        True,
+        False,
+        "손 검출 overlay(랜드마크/STABLE 라벨)를 rqt_image_view 창으로 표시. 손 검출 시작 버튼이 먼저 켜져 있어야 영상이 나옴",
+    ),
+    Step(
+        "handover_cup_to_palm",
+        "쉐이킹 후 손바닥에 컵 건네기",
+        "run",
+        "tools/run/handover_cup_to_palm.py",
+        True,
+        True,
+        "실제모션 HRI: 손 검출이 먼저 켜져 있어야 함. 손바닥 위로 이동 후 외력 감시하며 저속 하강, 컵 release. "
+        "첫 사용 전 스펀지 테스트로 --release-tcp-above-palm-m 튜닝 필수",
+    ),
 ]
 
 processes: dict[str, subprocess.Popen[str]] = {}
@@ -868,13 +977,12 @@ class Step:
 RUN_LOCK = threading.Lock()
 ROS_ENV_LOCK = threading.Lock()
 ROS_ENV_CACHE: dict[str, str] | None = None
-# Use the same tmux session as the field-tested manual workflow.  Keeping the
-# panel and terminal commands in one session avoids split ownership where the
-# panel launches a second robot/camera stack while the operator is watching a
-# different one.
+# Use the same tmux session as the field-tested manual workflow for long-lived
+# panel jobs. The integrated reconnect command is intentionally excluded below:
+# it runs stop_azas_all.sh, which kills azas-logic before recreating it, so that
+# command must be launched by the panel server outside tmux.
 PANEL_TMUX_SESSION = "azas-logic"
 PANEL_TMUX_STEPS = {
-    "connect_robot",
     "connect_gripper",
     "start_camera",
     "start_camera_view",
@@ -887,6 +995,32 @@ class Step:
     "cup_uprighting",
     "lid_grip_close",
     "shake_rviz_preview",
+    "start_hand_detection",
+    "start_hand_detection_view",
+}
+PANEL_HIDDEN_STEP_KEYS = {
+    "rviz_cocktail_collision_preview",
+    "rviz_color_scan_pose_preview",
+    "shake_rviz_preview",
+    "stop_cocktail_motion_preview",
+    "check_one_click_cocktail_ready",
+    "check_one_click_cocktail_result",
+    "run_cocktail_now_real",
+    "start_camera_view",
+    "detect_cup_lid",
+    "run_one_click_cocktail_real",
+    "move_to_dispenser_1",
+    "move_to_dispenser_2",
+    "move_to_dispenser_3",
+    "move_to_dispenser_4",
+    "press_dispenser_1",
+    "press_dispenser_2",
+    "press_dispenser_3",
+    "press_dispenser_4",
+    "pick_from_dispenser_1",
+    "pick_from_dispenser_2",
+    "pick_from_dispenser_3",
+    "pick_from_dispenser_4",
 }
 PANEL_DIRECT_TMUX_STEPS = {
     # Match the successful field workflow: the panel opens the same tmux launch
@@ -902,6 +1036,7 @@ class Step:
     # are not enough for real-motion GUI workflows.
     "side_grip",
     "cup_uprighting",
+    "lid_grip_close",
 }
 
 DOOSAN_STACK_PATTERNS = (
@@ -982,12 +1117,17 @@ class Step:
 )
 
 SIDE_GRIP_STACK_PATTERNS = (
+    "run_changhyun_side_grip_direct.sh",
     "yolo_cup_pick_node.launch.py",
     "yolo_cup_pick_node_legacy.launch.py",
     "yolo_cup_pick_legacy_node",
     "dsr_practice/yolo_cup_pick_node",
     "yolo_cup_pick_node --ros-args",
     "yolo_cup_pick_moveit_py",
+    "hand_eye_static_tf_node",
+    "link6_gripper_collision_node",
+    "workspace_collision_scene_node",
+    "--frame-id world --child-frame-id base_link",
 )
 
 CUP_UPRIGHTING_STACK_PATTERNS = (
@@ -2000,6 +2140,16 @@ def required_services_for_step(step: Step, service_prefix: str) -> list[str]:
             f"/{clean}/system/get_robot_state",
             "/check_state_validity",
         ]
+    if step.key == "handover_cup_to_palm":
+        return [
+            "/jarvis/rg2/set_width",
+            f"/{clean}/motion/move_line",
+            f"/{clean}/motion/ikin",
+            f"/{clean}/motion/check_motion",
+            f"/{clean}/aux_control/get_current_posx",
+            f"/{clean}/aux_control/get_tool_force",
+            f"/{clean}/system/get_robot_state",
+        ]
     return []
 
 
@@ -2021,7 +2171,7 @@ def required_service_wait_timeout(step: Step) -> float:
         or step.key == "lid_grip_close"
     ):
         return 35.0
-    if step.key in {"home_robot", "lift_robot", "side_grip_camera_home", "lid_view_pose", "move_to_color_scan_pose", "side_grip", "shake_closed_cup"}:
+    if step.key in {"home_robot", "lift_robot", "side_grip_camera_home", "lid_view_pose", "move_to_color_scan_pose", "side_grip", "shake_closed_cup", "handover_cup_to_palm"}:
         return 30.0
     if step.key == "gripper_soft_grasp":
         return 12.0
@@ -2104,12 +2254,10 @@ def wait_for_collision_object_sample(
     timeout_sec: float = 10.0,
     proc: subprocess.Popen[str] | None = None,
 ) -> tuple[bool, str]:
-    """Wait until workspace objects and the link_6 gripper attachment are visible."""
+    """Wait until workspace collision objects are visible."""
     deadline = time.monotonic() + max(timeout_sec, 0.1)
     last_collision_output = ""
-    last_attached_output = ""
     saw_collision = False
-    saw_attached_gripper = False
     while time.monotonic() < deadline:
         if proc is not None and proc.poll() is not None:
             return False, "collision scene process exited while waiting\n" + tail_file(process_logs.get("start_collision_scene"))
@@ -2127,38 +2275,17 @@ def wait_for_collision_object_sample(
         if collision_result.returncode == 0 and "id:" in collision_result.stdout:
             saw_collision = True
 
-        attached_result = subprocess.run(
-            ["bash", "-lc", "timeout 2s ros2 topic echo /attached_collision_object --once"],
-            cwd=str(ROOT),
-            env=env,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.STDOUT,
-            text=True,
-            timeout=3.0,
-            check=False,
-        )
-        last_attached_output = attached_result.stdout[-2000:]
-        if (
-            attached_result.returncode == 0
-            and "azas_rg2_gripper_on_link6" in attached_result.stdout
-            and "link_name: link_6" in attached_result.stdout
-        ):
-            saw_attached_gripper = True
-
-        if saw_collision and saw_attached_gripper:
+        if saw_collision:
             return (
                 True,
                 "collision object sample observed on /collision_object\n"
-                + last_collision_output
-                + "\nattached RG2 gripper envelope observed on /attached_collision_object\n"
-                + last_attached_output,
+                + last_collision_output,
             )
         time.sleep(0.5)
     return False, (
         f"scene readiness incomplete within {timeout_sec:.1f}s "
-        f"(workspace={saw_collision}, link6_gripper={saw_attached_gripper})\n"
-        f"--- last /collision_object ---\n{last_collision_output}\n"
-        f"--- last /attached_collision_object ---\n{last_attached_output}"
+        f"(workspace={saw_collision})\n"
+        f"--- last /collision_object ---\n{last_collision_output}"
     )
 
 
@@ -2208,6 +2335,37 @@ def wait_for_camera_topic_samples(
     )
 
 
+def realsense_usb_visible() -> tuple[bool, str]:
+    """Return whether an Intel RealSense device is visible to the OS."""
+    try:
+        result = subprocess.run(
+            ["lsusb"],
+            cwd=str(ROOT),
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            text=True,
+            timeout=3.0,
+            check=False,
+        )
+    except (OSError, subprocess.TimeoutExpired) as exc:
+        return False, f"[FAIL] lsusb check failed: {exc}"
+    output = result.stdout.strip()
+    if result.returncode != 0:
+        return False, "[FAIL] lsusb returned non-zero\n" + output
+    visible = any(
+        ("Intel" in line and "RealSense" in line)
+        or "8086:0b" in line.lower()
+        for line in output.splitlines()
+    )
+    if visible:
+        return True, "[OK] RealSense USB device visible\n" + output
+    return (
+        False,
+        "[FAIL] RealSense USB device is not visible to lsusb. "
+        "카메라 ROS 재시작으로는 복구되지 않습니다.\n" + output,
+    )
+
+
 def wait_for_tf_transform(
     *,
     env: dict[str, str],
@@ -2506,6 +2664,12 @@ def side_grip_preflight(env: dict[str, str], service_prefix: str) -> tuple[bool,
             + ", ".join(str(path) for path in calibration_candidates)
         )
 
+    usb_ok, usb_output = realsense_usb_visible()
+    checks.append("--- RealSense USB ---\n" + usb_output)
+    if not usb_ok:
+        ok = False
+        return ok, "\n".join(checks)
+
     camera_ready, camera_output = wait_for_camera_topic_samples(env=env, timeout_sec=5.0)
     if not camera_ready:
         # 카메라가 depth 없이 켜져 있을 수 있음 → 자동 재시작
@@ -2576,6 +2740,12 @@ def cup_uprighting_preflight(env: dict[str, str], service_prefix: str) -> tuple[
         ok = False
         checks.append(f"[FAIL] cup_uprighting YOLO model missing: {CUP_UPRIGHTING_YOLO_MODEL_PATH}")
 
+    usb_ok, usb_output = realsense_usb_visible()
+    checks.append("--- RealSense USB ---\n" + usb_output)
+    if not usb_ok:
+        ok = False
+        return ok, "\n".join(checks)
+
     camera_ready, camera_output = wait_for_camera_topic_samples(env=env, timeout_sec=5.0)
     checks.append("--- camera topics ---\n" + camera_output)
     if not camera_ready:
@@ -2973,73 +3143,28 @@ def requires_collision_scene_step(key: str) -> bool:
 
 
 def with_collision_scene_prereq(selected: list[str]) -> list[str]:
-    ordered = list(dict.fromkeys(selected))
-
-    def ensure_before(target: str, prerequisites: list[str]) -> None:
-        if target not in ordered:
-            return
-        target_index = ordered.index(target)
-        for prereq in prerequisites:
-            if prereq in ordered:
-                prereq_index = ordered.index(prereq)
-                if prereq_index < target_index:
-                    continue
-                ordered.pop(prereq_index)
-                if prereq_index < target_index:
-                    target_index -= 1
-        target_index = ordered.index(target)
-        missing = [
-            prereq
-            for prereq in prerequisites
-            if prereq not in ordered[:target_index]
-        ]
-        for offset, prereq in enumerate(missing):
-            ordered.insert(target_index + offset, prereq)
-
-    # 창현/소명/강개발자 수동 OpenCV 로직은 검증된 tmux stack을 사용한 뒤
-    # 단독 버튼으로 실행한다. 서버가 connect/status/camera 단계를 다시 끼워
-    # 넣으면 패널 실행 경로가 수동 tmux 경로와 달라지고 느려진다.
-
-    # Color classification must aim the robot at the measured color-scan pose
-    # before sampling the dispenser image.  If the camera is already running from
-    # side-grip, keep it there; otherwise start it before color_scan.
-    ensure_before(
-        "color_scan",
-        ["connect_robot", "status_check", "move_to_color_scan_pose", "start_camera"],
-    )
-
-    # The measured dispenser recipe assumes the cup has already been grasped by
-    # side_grip or an equivalent operator-verified step.  Here we only ensure the
-    # real-motion services and gripper service are available before the cycle.
-    ensure_before(
-        "run_color_recipe_sequence",
-        ["connect_robot", "status_check", "connect_gripper"],
-    )
-
-    first_collision_index = next(
-        (
-            index
-            for index, key in enumerate(ordered)
-            if requires_collision_scene_step(key)
-        ),
-        -1,
-    )
-    if first_collision_index >= 0:
-        existing_scene_index = (
-            ordered.index("start_collision_scene") if "start_collision_scene" in ordered else -1
-        )
-        if existing_scene_index < 0 or existing_scene_index > first_collision_index:
-            ordered = [key for key in ordered if key != "start_collision_scene"]
-            first_collision_index = next(
-                (
-                    index
-                    for index, key in enumerate(ordered)
-                    if requires_collision_scene_step(key)
-                ),
-                0,
-            )
-            ordered.insert(first_collision_index, "start_collision_scene")
-    return list(dict.fromkeys(ordered))
+    ordered: list[str] = []
+
+    def append_once(key: str) -> None:
+        if key not in ordered:
+            ordered.append(key)
+
+    for key in selected:
+        if key == "color_scan":
+            for prereq in (
+                "connect_robot",
+                "status_check",
+                "start_collision_scene",
+                "move_to_color_scan_pose",
+                "start_camera",
+            ):
+                append_once(prereq)
+        elif requires_collision_scene_step(key):
+            for prereq in ("connect_robot", "status_check", "start_collision_scene"):
+                append_once(prereq)
+        append_once(key)
+
+    return ordered
 
 
 def configure_manual_recipe_chain(selected: list[str], payload: dict[str, Any]) -> list[str]:
@@ -3101,7 +3226,12 @@ def shell_env(payload: dict[str, Any]) -> dict[str, str]:
     env["CUP_HOLDER_PLACE_FINAL_Z_OFFSET_M"] = str(
         payload.get("cup_holder_place_final_z_offset_m")
         or env.get("CUP_HOLDER_PLACE_FINAL_Z_OFFSET_M")
-        or "-0.020"
+        or "-0.030"
+    )
+    env["CUP_HOLDER_PLACE_FINAL_Y_OFFSET_M"] = str(
+        payload.get("cup_holder_place_final_y_offset_m")
+        or env.get("CUP_HOLDER_PLACE_FINAL_Y_OFFSET_M")
+        or "-0.010"
     )
     # Operational-only offset for the pre-shake cup-holder re-grasp.
     # This intentionally does not modify calibration.yaml and is separate from the
@@ -3141,56 +3271,9 @@ def tumbler_scene_once(action: str, *, object_id: str = "carried_tumbler", dispe
         )
 
     if step.key == "connect_robot":
-        robot_host = str(payload.get("robot_host") or os.environ.get("ROBOT_HOST") or DEFAULT_ROBOT_HOST)
-        robot_name = str(payload.get("robot_name") or os.environ.get("ROBOT_NAME") or "dsr01")
-        rt_host = str(
-            payload.get("rt_host")
-            or os.environ.get("RT_HOST")
-            or DEFAULT_RT_HOST
-        )
-        relay_script_path = ROOT / "src" / "dsr_practice" / "dsr_practice" / "joint_state_relay.py"
-        relay_input = f"/{robot_name.strip('/') or 'dsr01'}/joint_states"
-        relay_script = (
-            "sleep 12; "
-            f"cd {shlex.quote(str(ROOT))} && {ROS_SETUP}; "
-            f"if [ -f {shlex.quote(str(relay_script_path))} ]; then "
-            "echo '[Azas] starting RViz /joint_states relay "
-            f"{relay_input} -> /joint_states'; "
-            f"python3 {shlex.quote(str(relay_script_path))} --ros-args "
-            "-r __node:=azas_joint_state_relay "
-            f"-p input_topic:={shlex.quote(relay_input)} "
-            "-p output_topic:=/joint_states; "
-            "else echo '[WARN] joint_state_relay.py not found; RViz may not mirror real robot joints'; fi"
-        )
-        bringup_script = (
-            f"cd {shlex.quote(str(ROOT))} && "
-            f"ROBOT_HOST={shlex.quote(robot_host)} "
-            f"ROBOT_NAME={shlex.quote(robot_name)} RT_HOST={shlex.quote(rt_host)} "
-            "DOOSAN_REAL_MOTION_CONFIRM=ENABLE_DOOSAN_REAL_MOTION_BRINGUP "
-            f"{step.command} & "
-            "bringup_pid=$!; "
-            f"( {relay_script} ) & "
-            "wait $bringup_pid"
-        )
-        return f"bash -lc {shlex.quote(bringup_script)}"
+        return tmux_stack_start_command(payload)
     if step.key == "start_tmux_stack":
-        robot_host = str(payload.get("robot_host") or os.environ.get("ROBOT_HOST") or DEFAULT_ROBOT_HOST)
-        robot_name = str(payload.get("robot_name") or os.environ.get("ROBOT_NAME") or "dsr01")
-        rt_host = str(payload.get("rt_host") or os.environ.get("RT_HOST") or DEFAULT_RT_HOST)
-        rg2_ip = str(payload.get("rg2_ip") or os.environ.get("RG2_IP") or "192.168.1.1")
-        ros_domain_id = str(payload.get("ros_domain_id") or os.environ.get("AZAS_PANEL_ROS_DOMAIN_ID") or os.environ.get("ROS_DOMAIN_ID") or DEFAULT_ROS_DOMAIN_ID)
-        ros_localhost_only = str(os.environ.get("ROS_LOCALHOST_ONLY") or "0")
-        return (
-            f"cd {ROOT} && "
-            f"SESSION={shlex.quote(PANEL_TMUX_SESSION)} "
-            f"ROS_DOMAIN_ID={shlex.quote(ros_domain_id)} "
-            f"ROS_LOCALHOST_ONLY={shlex.quote(ros_localhost_only)} "
-            f"ROBOT_HOST={shlex.quote(robot_host)} "
-            f"ROBOT_NAME={shlex.quote(robot_name)} "
-            f"RT_HOST={shlex.quote(rt_host)} "
-            f"RG2_IP={shlex.quote(rg2_ip)} "
-            f"bash {shlex.quote(str(ROOT / 'tools' / 'run' / 'start_azas_tmux_stack.sh'))}"
-        )
+        return tmux_stack_start_command(payload)
     if step.key == "status_check":
         clean = service_prefix.strip("/") or "dsr01"
         return (
@@ -3359,15 +3442,8 @@ def tumbler_scene_once(action: str, *, object_id: str = "carried_tumbler", dispe
             "dispenser_collision_publish_markers:=true & "
             "ros2 launch azas_bringup rg2_link6_tcp.launch.py "
             "publish_gripper_collision:=false & "
-            "(timeout 12s ros2 run azas_motion link6_gripper_collision_node "
+            "timeout 12s ros2 run azas_motion link6_gripper_collision_node "
             "--ros-args -p operation:=remove -p publish_once:=true -p publish_markers:=false || true; "
-            "ros2 run azas_motion link6_gripper_collision_node "
-            "--ros-args "
-            "-p palm_size_x_m:=0.075 -p palm_size_y_m:=0.115 -p palm_size_z_m:=0.040 -p palm_z_m:=0.070 "
-            "-p finger_size_x_m:=0.030 -p finger_size_y_m:=0.014 -p finger_size_z_m:=0.120 "
-            "-p finger_y_m:=0.050 -p finger_z_m:=0.125 "
-            "-p pad_size_x_m:=0.022 -p pad_size_y_m:=0.010 -p pad_size_z_m:=0.025 "
-            "-p pad_y_m:=0.037 -p pad_z_m:=0.180) & "
             "ros2 run tf2_ros static_transform_publisher "
             "--x 0 --y 0 --z 0 --yaw 0 --pitch 0 --roll 0 "
             "--frame-id world --child-frame-id base_link & "
@@ -3401,6 +3477,13 @@ def tumbler_scene_once(action: str, *, object_id: str = "carried_tumbler", dispe
             "XAUTHORITY=${XAUTHORITY:-/run/user/1000/gdm/Xauthority} "
             "ros2 run rqt_image_view rqt_image_view /camera/camera/color/image_raw"
         )
+    if step.key == "start_hand_detection_view":
+        return (
+            f"cd {ROOT} && {ROS_SETUP} && "
+            "DISPLAY=${DISPLAY:-:0} "
+            "XAUTHORITY=${XAUTHORITY:-/run/user/1000/gdm/Xauthority} "
+            "ros2 run rqt_image_view rqt_image_view /azas/human_hand_detection/overlay"
+        )
     if step.key == "detect_cup_lid":
         return f"cd {ROOT} && {ROS_SETUP} && ros2 launch azas_bringup yolo_perception.launch.py"
     if step.key == "pick_lid":
@@ -3410,13 +3493,17 @@ def tumbler_scene_once(action: str, *, object_id: str = "carried_tumbler", dispe
         )
     if step.key == "lid_grip_close":
         direct_script = ROOT / "tools" / "run" / "run_kang_lid_grip_close_direct.sh"
-        return (
+        manual_cmd = (
             f"cd {ROOT} && "
             f"SERVICE_PREFIX={shlex.quote(service_prefix)} "
             "DISPLAY=${DISPLAY:-:0} "
             "XAUTHORITY=${XAUTHORITY:-/run/user/1000/gdm/Xauthority} "
+            "MOVE_TO_LID_VIEW_POSE=true "
             f"bash {shlex.quote(str(direct_script))}"
         )
+        if payload.get("_auto_shake_after_lid_grip_close", True):
+            return chain_shake_after_lid_command(manual_cmd, payload)
+        return manual_cmd
     if step.key == "cup_uprighting":
         direct_script = ROOT / "tools" / "run" / "run_somyeong_cup_uprighting_direct.sh"
         manual_cmd = (
@@ -3432,17 +3519,28 @@ def tumbler_scene_once(action: str, *, object_id: str = "carried_tumbler", dispe
             return chain_recipe_after_manual_command(manual_cmd, payload, "소명 cup_uprighting")
         return manual_cmd
     if step.key == "voice_input":
-        return f"cd {ROOT} && {ROS_SETUP} && ros2 launch azas_voice azas_voice.launch.py"
+        return (
+            f"cd {ROOT} && {ROS_SETUP} && "
+            "echo '[Azas] 수빈 STT/주문 UI: voice screen http://localhost:8090' && "
+            "echo '[Azas] 메뉴를 말하거나 테스트 발화 입력 후, 응/시작으로 확정하면 listen_stt_recipe가 latest_recipe.json을 저장합니다.' && "
+            "ros2 launch azas_voice azas_voice.launch.py run_voice_screen:=true"
+        )
     if step.key == "side_grip":
         direct_script = ROOT / "tools" / "run" / "run_changhyun_side_grip_direct.sh"
+        side_target_x_offset_m = str(
+            payload.get("side_target_x_offset_m")
+            or os.environ.get("SIDE_TARGET_X_OFFSET_M")
+            or "-0.020"
+        )
         manual_cmd = (
             f"cd {ROOT} && "
             f"SERVICE_PREFIX={shlex.quote(service_prefix)} "
+            f"SIDE_TARGET_X_OFFSET_M={shlex.quote(side_target_x_offset_m)} "
             "DISPLAY=${DISPLAY:-:0} "
             "XAUTHORITY=${XAUTHORITY:-/run/user/1000/gdm/Xauthority} "
             f"bash {shlex.quote(str(direct_script))}"
         )
-        if payload.get("_auto_recipe_after_manual_logic"):
+        if payload.get("_auto_recipe_after_manual_logic", True):
             return chain_recipe_after_manual_command(manual_cmd, payload, "창현 side_grip")
         return manual_cmd
     if step.key == "gripper_soft_grasp":
@@ -3586,7 +3684,12 @@ def tumbler_scene_once(action: str, *, object_id: str = "carried_tumbler", dispe
         place_final_z_offset_m = str(
             payload.get("cup_holder_place_final_z_offset_m")
             or os.environ.get("CUP_HOLDER_PLACE_FINAL_Z_OFFSET_M")
-            or "-0.020"
+            or "-0.030"
+        ).strip()
+        place_final_y_offset_m = str(
+            payload.get("cup_holder_place_final_y_offset_m")
+            or os.environ.get("CUP_HOLDER_PLACE_FINAL_Y_OFFSET_M")
+            or "-0.010"
         ).strip()
         return (
             f"cd {ROOT} && {ROS_SETUP} && python3 tools/run/place_side_grip_cup_in_holder.py "
@@ -3596,10 +3699,11 @@ def tumbler_scene_once(action: str, *, object_id: str = "carried_tumbler", dispe
             "--moveit-planning-pipeline ompl --moveit-planner-id RRTConnectkConfigDefault "
             "--moveit-planning-time-sec 8.0 --moveit-planning-attempts 5 "
             "--moveit-velocity-scaling 0.08 --moveit-acceleration-scaling 0.06 "
-            "--approach-velocity 15.0 --approach-acceleration 20.0 "
+            "--approach-velocity 80.0 --approach-acceleration 20.0 "
+            f"--place-final-y-offset-m {shlex.quote(place_final_y_offset_m)} "
             f"--place-final-z-offset-m {shlex.quote(place_final_z_offset_m)} "
-            "--place-velocity 6.0 --place-acceleration 10.0 "
-            "--retreat-velocity 12.0 --retreat-acceleration 16.0 "
+            "--place-velocity 80.0 --place-acceleration 10.0 "
+            "--retreat-velocity 80.0 --retreat-acceleration 16.0 "
             "--timeout-sec 90.0 --target-tolerance-mm 12.0 --verify-timeout-sec 45.0 "
             "--z-max 0.28 "
             "--execute --confirm ENABLE_CUP_HOLDER_PLACE"
@@ -3658,6 +3762,35 @@ def tumbler_scene_once(action: str, *, object_id: str = "carried_tumbler", dispe
             "JOINT_TARGET_WAIT_EXTRA_SEC=3.0 JOINT_TARGET_POLL_SEC=0.05 "
             "REQUIRE_STATE_VALIDITY_FOR_JOINT_SHAKE=true "
             "tools/run/run_rule_based_shake_real.sh"
+            " && echo '[Azas] SHAKE DONE: 손 검출/핸드오버를 위해 카메라 포즈로 복귀합니다 (컵 파지 유지).' && "
+            "python3 tools/run/direct_movej_joints.py "
+            f"--service-prefix {service_prefix} "
+            "--j1 3.0 --j2 -12.7 --j3 44.0 --j4 -9.0 --j5 133.0 --j6 90.0 "
+            "--velocity 15 --acceleration 15 "
+            "--j5-min-deg -150 --j5-max-deg 150 --timeout-sec 60 --motion-timeout-sec 120 "
+            "--execute --confirm ENABLE_DIRECT_MOVEJ"
+        )
+    if step.key == "handover_cup_to_palm":
+        release_height_m = str(
+            payload.get("handover_release_tcp_above_palm_m")
+            or os.environ.get("HANDOVER_RELEASE_TCP_ABOVE_PALM_M")
+            or "0.08"
+        ).strip()
+        return (
+            f"cd {ROOT} && "
+            f"{ROS_SETUP} && "
+            "echo '[Azas] HANDOVER START: 펼친 손바닥을 추적해 컵을 손 위에 내려놓습니다.' && "
+            "echo '[Azas] 전제: 손 검출 시작 버튼이 켜져 있고, 받는 사람이 손바닥을 펴고 멈춰 있어야 합니다.' && "
+            "echo '[Azas] 안전: 하강은 2cm 스텝마다 외력을 확인하고, 손이 움직이면 자동 후퇴합니다.' && "
+            "python3 tools/run/handover_cup_to_palm.py "
+            f"--service-prefix {service_prefix} "
+            f"--release-tcp-above-palm-m {shlex.quote(release_height_m)} "
+            "--transit-velocity 10.0 --transit-acceleration 14.0 "
+            "--descent-velocity 4.0 --descent-acceleration 6.0 "
+            "--force-abort-delta-n 10.0 "
+            "--execute --confirm ENABLE_HUMAN_PALM_HANDOVER "
+            "--approve-motion ENABLE_HUMAN_PALM_HANDOVER_MOTION "
+            "--approve-release RELEASE_CUP_NOW"
         )
     if step.command.strip():
         return f"cd {ROOT} && {ROS_SETUP} && {step.command}"
@@ -3840,109 +3973,21 @@ def run_step(step: Step, payload: dict[str, Any]) -> dict[str, Any]:
     cmd = command_for(step, payload)
     if step.kind == "background":
         restart_output = ""
-        if step.key == "connect_robot":
-            ready, ready_output, _svc = motion_services_ready(env["SERVICE_PREFIX"])
-            if ready:
-                robot_ready, robot_ready_output = doosan_robot_ready(env["SERVICE_PREFIX"])
-                virtual_present, virtual_output = doosan_virtual_nodes_present(env["SERVICE_PREFIX"])
-                if robot_ready:
-                    note = ""
-                    if virtual_present:
-                        note = (
-                            "\n[INFO] /virtual_node 이름이 보이지만 robot_state=STATE_STANDBY(1) "
-                            "및 check_motion success=True라서 real bringup을 유지합니다. "
-                            "Doosan real launch에서도 이 노드명이 보일 수 있어 이름만으로 재시작하지 않습니다.\n"
-                            f"{virtual_output}"
-                        )
-                    return {
-                        "key": step.key,
-                        "status": "running",
-                        "output": (
-                            "이미 Doosan motion 서비스가 보이고 로봇이 STATE_STANDBY(1)입니다. "
-                            "재시작하지 않습니다.\n"
-                            f"{ready_output}\n{robot_ready_output}{note}"
-                        ),
-                    }
-                if virtual_present:
-                    cleanup_events = cleanup_doosan_stack(grace_sec=3.0)
-                    restart_output = (
-                        "기존 Doosan motion 서비스가 보이지만 virtual_node가 감지되어 실제 로봇 연결로 재시작합니다.\n"
-                        f"--- virtual nodes ---\n{virtual_output}\n"
-                        "--- cleanup ---\n"
-                        + ("\n".join(cleanup_events) if cleanup_events else "no cleanup events")
-                        + "\n"
-                    )
-                else:
-                    return {
-                        "key": step.key,
-                        "status": "blocked",
-                        "output": (
-                            "Doosan motion 서비스는 보이지만 로봇이 motion-ready 상태가 아닙니다. "
-                            "재시작하지 않습니다.\n"
-                            f"{ready_output}\n"
-                            "티치펜던트/컨트롤러에서 빨간 상태(SAFE_OFF/보호정지/서보 상태)를 해제해 "
-                            "STATE_STANDBY(1)로 만든 뒤 다시 확인하세요.\n"
-                            f"{robot_ready_output}"
-                        ),
-                    }
-            old = processes.get(step.key)
-            if old and old.poll() is None:
-                ready, waited_output = wait_for_motion_services_ready(
-                    env["SERVICE_PREFIX"],
-                    timeout_sec=20.0,
-                    proc=old,
-                )
-                if ready:
-                    robot_ready, robot_ready_output = doosan_robot_ready(env["SERVICE_PREFIX"])
-                    if robot_ready:
-                        return {
-                            "key": step.key,
-                            "status": "running",
-                            "output": (
-                                "기존 로봇 연결 프로세스가 계속 실행 중이고 motion 서비스가 준비됐습니다.\n"
-                                f"{waited_output}\n{robot_ready_output}"
-                            ),
-                            "pid": old.pid,
-                        }
-                    return {
-                        "key": step.key,
-                        "status": "blocked",
-                        "output": (
-                            "기존 로봇 연결 프로세스가 motion 서비스를 띄웠지만 로봇이 "
-                            "STATE_STANDBY(1)가 아닙니다.\n"
-                            f"{waited_output}\n{robot_ready_output}"
-                        ),
-                        "pid": old.pid,
-                    }
-                log_tail = tail_file(process_logs.get(step.key))
-                cleanup_events = cleanup_doosan_stack(grace_sec=3.0)
-                time.sleep(1.5)
-                restart_output = (
-                    "기존 로봇 연결 프로세스가 motion 서비스를 준비하지 못해 재연결합니다.\n"
-                    f"pid={old.pid}\n"
-                    f"--- readiness ---\n{waited_output}\n"
-                    f"--- previous log tail ---\n{log_tail}\n"
-                    "--- cleanup ---\n"
-                    + ("\n".join(cleanup_events) if cleanup_events else "no cleanup events")
-                    + "\n"
-                )
-            existing_pid, existing_cmd = find_existing_doosan_launch()
-            if existing_pid is not None and not restart_output:
-                cleanup_events = cleanup_doosan_stack(grace_sec=3.0)
-                time.sleep(1.5)
-                restart_output = (
-                    "기존 Doosan bringup이 있으나 motion 서비스가 준비되지 않아 재연결합니다.\n"
-                    f"pid={existing_pid}\ncmd={existing_cmd[:500]}\n"
-                    f"--- readiness ---\n{ready_output}\n"
-                    "--- cleanup ---\n"
-                    + ("\n".join(cleanup_events) if cleanup_events else "no cleanup events")
-                    + "\n"
+        if step.key in {"connect_robot", "start_tmux_stack"}:
+            cleanup_events: list[str] = []
+            cleanup_events.extend(cleanup_side_grip_stack(grace_sec=3.0))
+            cleanup_events.extend(cleanup_camera_stack(grace_sec=3.0))
+            cleanup_events.extend(cleanup_rg2_stack(grace_sec=3.0))
+            restart_output = "\n".join(
+                part
+                for part in (
+                    "[Azas] tmux 통합 재연결: stop_azas_all.sh가 azas-logic tmux 세션을 종료하므로 "
+                    "패널 서버가 tmux 밖에서 터미널과 같은 stop -> start 명령을 직접 실행합니다.",
+                    "[Azas] reconnect pre-cleanup: 이전 side_grip/camera/RG2 잔여 프로세스를 먼저 정리합니다.",
+                    "\n".join(cleanup_events),
                 )
-            if not restart_output:
-                cleanup_events = cleanup_doosan_stack()
-                # Give DDS/service discovery a short moment to forget killed duplicate nodes.
-                time.sleep(1.5)
-                restart_output = "\n".join(cleanup_events)
+                if part
+            )
         elif step.key == "connect_gripper":
             cleanup_events = cleanup_rg2_stack()
             # DDS may keep stale service names briefly after a killed RG2 wrapper.
@@ -3990,17 +4035,21 @@ def run_step(step: Step, payload: dict[str, Any]) -> dict[str, Any]:
         log_handle.close()
         processes[step.key] = proc
         process_logs[step.key] = log_path
-        if step.key == "start_tmux_stack":
+        if step.key in {"start_tmux_stack", "connect_robot"}:
             try:
                 proc.wait(timeout=90.0)
             except subprocess.TimeoutExpired:
                 output = (
                     f"{cmd}\n--- log ---\n{log_path}\n"
-                    "tmux 연결 스택 스크립트가 90초 안에 종료되지 않았습니다.\n"
+                    "tmux 통합 재연결 명령이 90초 안에 종료되지 않았습니다.\n"
                     + tail_file(log_path, max_chars=8000)
                 )
+                if restart_output:
+                    output = f"{restart_output}\n--- start command ---\n{output}"
                 return {"key": step.key, "status": "starting", "pid": proc.pid, "output": output}
             output = f"{cmd}\n--- log ---\n{log_path}\n--- start output ---\n{tail_file(log_path, max_chars=10000)}"
+            if restart_output:
+                output = f"{restart_output}\n--- start command ---\n{output}"
             if proc.returncode != 0:
                 return {"key": step.key, "status": "failed", "returncode": proc.returncode, "output": output}
             return {
@@ -4009,84 +4058,12 @@ def run_step(step: Step, payload: dict[str, Any]) -> dict[str, Any]:
                 "pid": proc.pid,
                 "output": (
                     output
-                    + "\n[Azas] tmux 창 생성 성공. robot/gripper/camera/joint_relay는 각 tmux 창 로그를 기준으로 확인합니다. "
+                    + "\n[Azas] tmux 통합 재연결 명령 완료. robot/gripper/camera/joint_relay는 각 tmux 창 로그를 기준으로 확인합니다. "
                     "ROS CLI daemon/discovery 오류 때문에 이 단계에서 후속 조회로 차단하지 않습니다."
                 ),
             }
 
-            service_prefix = env["SERVICE_PREFIX"]
-            motion_ok, motion_output = real_motion_readiness_gate(
-                service_prefix,
-                motion_timeout_sec=45.0,
-            )
-            gripper_ok, gripper_output = wait_for_required_services(
-                ["/jarvis/rg2/open", "/jarvis/rg2/close", "/jarvis/rg2/set_width"],
-                timeout_sec=10.0,
-            )
-            camera_ok, camera_output = wait_for_camera_topic_samples(env=env, timeout_sec=12.0)
-            output += (
-                "\n--- robot readiness ---\n"
-                + motion_output
-                + "\n--- gripper readiness ---\n"
-                + gripper_output
-                + "\n--- camera readiness ---\n"
-                + camera_output
-            )
-            if motion_ok and gripper_ok and camera_ok:
-                return {"key": step.key, "status": "passed", "pid": proc.pid, "output": output}
-            return {
-                "key": step.key,
-                "status": "blocked",
-                "pid": proc.pid,
-                "output": (
-                    "tmux 창은 시작했지만 로봇/그리퍼/카메라 준비 조건이 완성되지 않았습니다. "
-                    "side-grip을 시작하지 않습니다.\n"
-                    + output
-                ),
-            }
-        if step.key == "connect_robot":
-            ready, waited_output = wait_for_motion_services_ready(
-                env["SERVICE_PREFIX"],
-                timeout_sec=35.0,
-                proc=proc,
-            )
-            if ready:
-                robot_ready, robot_ready_output = doosan_robot_ready(env["SERVICE_PREFIX"])
-                output = f"{cmd}\n--- log ---\n{log_path}\n--- readiness ---\n{waited_output}\n{robot_ready_output}"
-                if restart_output:
-                    output = f"{restart_output}\n--- start command ---\n{output}"
-                if robot_ready:
-                    return {
-                        "key": step.key,
-                        "status": "passed",
-                        "pid": proc.pid,
-                        "output": output,
-                    }
-                return {
-                    "key": step.key,
-                    "status": "blocked",
-                    "pid": proc.pid,
-                    "output": (
-                        "로봇 연결 프로세스는 시작됐고 motion 서비스도 보이지만 "
-                        "로봇이 STATE_STANDBY(1)가 아닙니다.\n"
-                        + output
-                    ),
-                }
-            if proc.poll() is None:
-                output = (
-                    f"{cmd}\n--- log ---\n{log_path}\n--- readiness ---\n{waited_output}\n"
-                    "아직 시작 중입니다. 몇 초 뒤 '연결 확인'만 다시 눌러주세요."
-                )
-                if restart_output:
-                    output = f"{restart_output}\n--- start command ---\n{output}"
-                return {
-                    "key": step.key,
-                    "status": "starting",
-                    "pid": proc.pid,
-                    "output": output,
-                }
-        else:
-            time.sleep(2.0)
+        time.sleep(2.0)
         if proc.poll() is not None:
             output = tail_file(log_path)
             if restart_output:
@@ -4361,9 +4338,17 @@ def do_GET(self) -> None:
                     "DISPENSER_TCP_NAME", DEFAULT_DISPENSER_TCP_NAME
                 ),
                 "selected_dispenser_id": os.environ.get("SELECTED_DISPENSER_ID", "2"),
+                "cup_holder_place_final_y_offset_m": os.environ.get(
+                    "CUP_HOLDER_PLACE_FINAL_Y_OFFSET_M", "-0.010"
+                ),
+                "cup_holder_place_final_z_offset_m": os.environ.get(
+                    "CUP_HOLDER_PLACE_FINAL_Z_OFFSET_M", "-0.030"
+                ),
             }
             data = []
             for step in STEPS:
+                if step.key in PANEL_HIDDEN_STEP_KEYS:
+                    continue
                 item = asdict(step)
                 item["resolved_command"] = command_for(step, preview_payload) if step.implemented else ""
                 item["command_saved"] = step.key in command_overrides
@@ -4377,6 +4362,17 @@ def do_GET(self) -> None:
             self.send_json(dispenser_color_map_status())
             return
         if path == "/api/camera_snapshot.jpg":
+            if os.environ.get("AZAS_PANEL_ENABLE_CAMERA_SNAPSHOT", "0") not in {"1", "true", "TRUE"}:
+                message = b"camera snapshot endpoint disabled in field panel"
+                try:
+                    self.send_response(404)
+                    self.send_header("Content-Type", "text/plain; charset=utf-8")
+                    self.send_header("Content-Length", str(len(message)))
+                    self.end_headers()
+                    self.wfile.write(message)
+                except BrokenPipeError:
+                    pass
+                return
             ok, body, error = camera_snapshot_jpeg()
             if not ok:
                 self.send_response(503)
@@ -4426,6 +4422,15 @@ def do_POST(self) -> None:
                 steps_by_key = {step.key: step for step in STEPS}
                 results = []
                 for key in selected:
+                    if key in PANEL_HIDDEN_STEP_KEYS:
+                        results.append(
+                            {
+                                "key": key,
+                                "status": "blocked",
+                                "output": "이 단계는 패널에서 제거된 내부/구버전 단계라 실행하지 않았습니다.",
+                            }
+                        )
+                        break
                     step = steps_by_key.get(key)
                     if step is None:
                         continue
diff --git a/tools/run/run_changhyun_side_grip_direct.sh b/tools/run/run_changhyun_side_grip_direct.sh
index ed81e63..f406d45 100755
--- a/tools/run/run_changhyun_side_grip_direct.sh
+++ b/tools/run/run_changhyun_side_grip_direct.sh
@@ -71,19 +71,10 @@ ros2 run tf2_ros static_transform_publisher \
 ros2 run azas_perception hand_eye_static_tf_node \
   --ros-args -p compose_timeout_sec:=30.0 -p allow_direct_fallback:=false &
 
-# Publish only the attached RG2/link_6 collision object before launching the
-# picker. Keep the launch-side include disabled because it also starts an
-# auxiliary robot_state_publisher and can stall MoveItPy initialization in the
-# field tmux workflow.
+# The RG2 mesh is part of the M0609 MoveIt URDF. Remove the older attached
+# link_6 box envelope so it cannot duplicate the mesh in PlanningScene/RViz.
 timeout 12s ros2 run azas_motion link6_gripper_collision_node \
   --ros-args -p operation:=remove -p publish_once:=true -p publish_markers:=false || true
-ros2 run azas_motion link6_gripper_collision_node \
-  --ros-args \
-  -p palm_size_x_m:=0.075 -p palm_size_y_m:=0.115 -p palm_size_z_m:=0.040 -p palm_z_m:=0.070 \
-  -p finger_size_x_m:=0.030 -p finger_size_y_m:=0.014 -p finger_size_z_m:=0.120 \
-  -p finger_y_m:=0.050 -p finger_z_m:=0.125 \
-  -p pad_size_x_m:=0.022 -p pad_size_y_m:=0.010 -p pad_size_z_m:=0.025 \
-  -p pad_y_m:=0.037 -p pad_z_m:=0.180 &
 
 should_start_relay=false
 if [[ "${START_JOINT_STATE_RELAY:-auto}" == "true" ]]; then
@@ -105,6 +96,8 @@ if [[ "${should_start_relay}" == "true" ]]; then
   ) &
 fi
 
+side_grip_success_log="$(mktemp /tmp/azas_changhyun_side_grip.XXXXXX.log)"
+set +e
 ros2 launch dsr_practice yolo_cup_pick_node.launch.py \
   model_path:="${ROOT}/local_models/best.pt" \
   conf:=0.35 imgsz:=640 device:=cpu target_class:=cup \
@@ -113,6 +106,7 @@ ros2 launch dsr_practice yolo_cup_pick_node.launch.py \
   redetect_on_approach:=false redetect_settle_sec:=0.5 \
   grasp_mode:=side side_far_stage_enabled:=false side_approach_offset:=0.18 \
   side_short_stage_backoff_m:=0.08 side_grasp_stop_backoff_m:=0.04 side_close_underreach_m:=0.03 \
+  side_target_x_offset_m:="${SIDE_TARGET_X_OFFSET_M:--0.020}" \
   side_low_retry_lift_m:=0.0 side_low_retry_attempts:=0 \
   side_linear_approach_enabled:=true side_final_slide_enabled:=false \
   side_fixed_grasp_z_enabled:=false side_grasp_z_offset:=0.05 side_project_bbox_center_to_fixed_z:=false \
@@ -125,4 +119,20 @@ ros2 launch dsr_practice yolo_cup_pick_node.launch.py \
   workspace_boundary_collision_enabled:=true dispenser_collision_enabled:=true dispenser_collision_publish_objects:=true \
   dispenser_collision_publish_markers:=true link6_gripper_collision_enabled:=false \
   dispenser_collision_config_path:="${ROOT}/src/azas_bringup/config/measured_dispenser_collision.yaml" \
-  moveit_controller_name:=/"${SERVICE_PREFIX}"/dsr_moveit_controller start_joint_state_relay:=false
+  moveit_controller_name:=/"${SERVICE_PREFIX}"/dsr_moveit_controller start_joint_state_relay:=false \
+  2>&1 | tee "${side_grip_success_log}"
+launch_rc="${PIPESTATUS[0]}"
+set -e
+
+if [[ "${launch_rc}" -eq 0 ]] && grep -q "exit_after_pick=true and one pick completed" "${side_grip_success_log}"; then
+  echo "[Azas] CHANGHYUN_SIDE_GRIP_SUCCESS: pick completed; downstream integrated dispenser recipe may start."
+  exit 0
+fi
+
+if [[ "${launch_rc}" -eq 0 ]]; then
+  echo "[Azas] CHANGHYUN_SIDE_GRIP_NO_SUCCESS: node exited without completed-pick success marker; integrated dispenser recipe will not start."
+  exit 3
+fi
+
+echo "[Azas] CHANGHYUN_SIDE_GRIP_FAILED: ros2 launch exited rc=${launch_rc}; integrated dispenser recipe will not start."
+exit "${launch_rc}"
diff --git a/tools/run/run_color_recipe_sequence.py b/tools/run/run_color_recipe_sequence.py
index 1fe1a12..04f0f75 100644
--- a/tools/run/run_color_recipe_sequence.py
+++ b/tools/run/run_color_recipe_sequence.py
@@ -223,34 +223,43 @@ def main() -> int:
     )
     parser.add_argument("--execute", action="store_true",
                         help="실제 measured dispenser sequence를 실행")
-    parser.add_argument("--move-velocity", default="18.0")
+    parser.add_argument("--move-velocity", default="80.0")
     parser.add_argument("--move-acceleration", default="25.0")
-    parser.add_argument("--move-prehold-velocity", default="16.0")
+    parser.add_argument("--move-prehold-velocity", default="80.0")
     parser.add_argument("--move-prehold-acceleration", default="22.0")
-    parser.add_argument("--pick-approach-velocity", default="10.0")
+    parser.add_argument("--pick-approach-velocity", default="80.0")
     parser.add_argument("--pick-approach-acceleration", default="14.0")
-    parser.add_argument("--pick-lift-velocity", default="18.0")
+    parser.add_argument("--pick-lift-velocity", default="80.0")
     parser.add_argument("--pick-lift-acceleration", default="25.0")
-    parser.add_argument("--regrasp-approach-velocity", default="14.0")
+    parser.add_argument("--regrasp-approach-velocity", default="80.0")
     parser.add_argument("--regrasp-approach-acceleration", default="18.0")
+    parser.add_argument(
+        "--regrasp-reset-before-cup",
+        action=argparse.BooleanOptionalAction,
+        default=True,
+        help="프레스 후 컵 재접근 전에 HOME joint waypoint를 경유",
+    )
+    parser.add_argument("--regrasp-reset-joints-deg", default="0,0,90,0,90,180")
+    parser.add_argument("--regrasp-reset-joint-velocity", default="80.0")
+    parser.add_argument("--regrasp-reset-joint-acceleration", default="35.0")
     parser.add_argument("--press-min-transit-z-m", default="0.500")
-    parser.add_argument("--press-line-velocity", default="18.0")
-    parser.add_argument("--press-line-acceleration", default="25.0")
-    parser.add_argument("--press-travel-velocity", default="45.0")
-    parser.add_argument("--press-travel-acceleration", default="60.0")
-    parser.add_argument("--press-contact-joint-velocity", default="22.0")
-    parser.add_argument("--press-contact-joint-acceleration", default="30.0")
+    parser.add_argument("--press-line-velocity", default="25.0")
+    parser.add_argument("--press-line-acceleration", default="10.0")
+    parser.add_argument("--press-travel-velocity", default="40.0")
+    parser.add_argument("--press-travel-acceleration", default="20.0")
+    parser.add_argument("--press-contact-joint-velocity", default="35.0")
+    parser.add_argument("--press-contact-joint-acceleration", default="15.0")
     parser.add_argument("--press-contact-entry-lift-m", default="0.050")
     parser.add_argument(
         "--press-reset-before-press",
         action=argparse.BooleanOptionalAction,
         default=True,
-        help="컵을 놓은 뒤 프레스 PRE로 가기 전에 HOME joint waypoint를 경유",
+        help="컵을 놓은 뒤 CONTACT_ENTRY_LIFT 전에 PRESS_COMMON_PRE/HOME joint waypoint를 경유. 기본 false",
     )
     parser.add_argument("--press-reset-joints-deg", default="0,0,90,0,90,0")
-    parser.add_argument("--press-reset-joint-velocity", default="18.0")
+    parser.add_argument("--press-reset-joint-velocity", default="80.0")
     parser.add_argument("--press-reset-joint-acceleration", default="25.0")
-    parser.add_argument("--press-depth-m", default="0.040")
+    parser.add_argument("--press-depth-m", default="0.070")
     parser.add_argument(
         "--press-extra-depth-m",
         default="0.0",
@@ -258,10 +267,10 @@ def main() -> int:
     )
     parser.add_argument(
         "--press-lock-contact-joints",
-        default="6",
+        default="",
         help=(
-            "measured sequence로 전달할 contact 조인트 잠금 축. 기본 6: "
-            "호환 모드에서만 pre 자세 값으로 J6을 유지합니다. 기본 contact-only 경로에서는 사용하지 않습니다."
+            "measured sequence로 전달할 contact 조인트 잠금 축. 기본 빈 값: "
+            "측정된 PRESS_CONTACT joint를 그대로 사용합니다."
         ),
     )
     parser.add_argument("--press-pre-lift-m", default="0.080")
@@ -276,12 +285,74 @@ def main() -> int:
     parser.add_argument("--press-pre-lift-retreat-y-m", default="0.0")
     parser.add_argument("--move-release-offset-x-m", default="-0.020")
     parser.add_argument("--move-release-offset-y-m", default="0.0")
-    parser.add_argument("--move-release-offset-z-m", default="0.0")
+    parser.add_argument("--move-release-offset-z-m", default="0.010")
+    parser.add_argument("--cup-pre-from-place-x-offset-m", default="-0.090")
+    parser.add_argument("--cup-pre-from-place-z-offset-m", default="0.030")
+    parser.add_argument("--generated-cup-pre-max-joint-delta-deg", default="190.0")
+    parser.add_argument(
+        "--press-contact-use-joint-move",
+        action=argparse.BooleanOptionalAction,
+        default=False,
+        help="measured PRESS_CONTACT movej 사용. 기본 false: PRESS_CONTACT FK까지 Cartesian Z-only 하강",
+    )
+    parser.add_argument(
+        "--use-cup-common-pre",
+        action=argparse.BooleanOptionalAction,
+        default=False,
+        help="저장된 cup_common_pre_joints_deg를 사용. 기본 false: cup_place 기준 X/Z offset pre 생성",
+    )
     parser.add_argument("--regrasp-retreat-x-m", default="-0.080")
     parser.add_argument("--regrasp-retreat-y-m", default="0.0")
     parser.add_argument("--post-press-safe-lift-z-m", default="0.470")
-    parser.add_argument("--regrasp-rear-entry-offset-x-m", default="-0.080")
+    parser.add_argument(
+        "--start-safe-lift-z-m",
+        default="0.15",
+        help="시퀀스 시작 시 현재 TCP pose에서 Z-only로 먼저 올라갈 최소 절대 TCP Z (m)",
+    )
+    parser.add_argument(
+        "--min-allowed-tcp-z-m",
+        default="0.02",
+        help="모든 cartesian target pose의 최소 허용 TCP Z (m). 미달 target은 로봇 명령 전송 전에 차단",
+    )
+    parser.add_argument(
+        "--force-start-safe-lift",
+        action=argparse.BooleanOptionalAction,
+        default=True,
+        help="시작 시 항상 현재 위치에서 safe Z로 lift한 뒤 다음 waypoint로 이동 (기본 켜짐)",
+    )
+    parser.add_argument(
+        "--skip-release-pre",
+        action=argparse.BooleanOptionalAction,
+        default=False,
+        help="cup_place 기준 X/Z offset release-pre 대신 자세 무관 안전 release 구조 사용",
+    )
+    parser.add_argument("--release-approach-lift-m", default="0.100",
+                        help="release final 위에 생성할 release_above pose의 Z lift (m)")
+    parser.add_argument("--release-start-safe-lift-m", default="0.120",
+                        help="release 시작 시 현재 TCP에서 Z-only로 올릴 상대 높이 (m)")
+    parser.add_argument("--release-min-transit-z-m", default="0.300",
+                        help="release XY-transit pose의 최소 절대 TCP Z (m)")
+    parser.add_argument("--post-release-safe-lift-m", default="0.100",
+                        help="gripper open 후 release final에서 수직 상승할 높이 (m)")
+    parser.add_argument("--release-staging-x-m", default="",
+                        help="release staging pose 절대 X (m). 비우면 release final X 사용")
+    parser.add_argument("--release-staging-y-m", default="",
+                        help="release staging pose 절대 Y (m). 비우면 release final Y 사용")
+    parser.add_argument("--release-staging-z-m", default="",
+                        help="release staging pose 절대 Z (m). 비우면 transit 높이 사용")
+    parser.add_argument(
+        "--use-release-staging",
+        action=argparse.BooleanOptionalAction,
+        default=True,
+        help="release_above 진입 전에 staging pose를 경유 (기본 켜짐)",
+    )
+    parser.add_argument("--regrasp-rear-entry-offset-x-m", default="-0.090")
     parser.add_argument("--regrasp-rear-entry-offset-y-m", default="0.0")
+    parser.add_argument("--final-regrasp-extra-x-offset-m", default="0.020")
+    parser.add_argument("--final-regrasp-extra-y-offset-m", default="0.0")
+    parser.add_argument("--final-regrasp-extra-z-offset-m", default="0.0")
+    parser.add_argument("--final-regrasp-grasp-width-m", default="0.068")
+    parser.add_argument("--final-regrasp-force-n", default="35.0")
     parser.add_argument(
         "--allow-tcp-set-failure",
         action="store_true",
@@ -290,6 +361,22 @@ def main() -> int:
     parser.add_argument("--force-cartesian-press", action="store_true")
     parser.add_argument("--gripper-open-settle-seconds", default="1.5")
     parser.add_argument("--gripper-settle-seconds", default="0.8")
+    parser.add_argument(
+        "--place-cup-holder-after-sequence",
+        action=argparse.BooleanOptionalAction,
+        default=True,
+        help="마지막 디스펜서 처리 후 컵홀더에 컵을 놓음",
+    )
+    parser.add_argument("--cup-holder-place-final-z-offset-m", default="-0.030")
+    parser.add_argument("--cup-holder-place-final-y-offset-m", default="-0.010")
+    parser.add_argument("--cup-holder-approach-velocity", default="80.0")
+    parser.add_argument("--cup-holder-approach-acceleration", default="20.0")
+    parser.add_argument("--cup-holder-place-velocity", default="80.0")
+    parser.add_argument("--cup-holder-place-acceleration", default="10.0")
+    parser.add_argument("--cup-holder-retreat-velocity", default="80.0")
+    parser.add_argument("--cup-holder-retreat-acceleration", default="16.0")
+    parser.add_argument("--cup-holder-timeout-sec", default="90.0")
+    parser.add_argument("--cup-holder-target-tolerance-mm", default="12.0")
     parser.add_argument("--wait-service-sec", default="15.0")
     parser.add_argument("--pose-read-retries", default="3")
     parser.add_argument("--pose-read-retry-sleep-sec", default="0.5")
@@ -316,6 +403,9 @@ def main() -> int:
         "--pick-lift-acceleration", str(args.pick_lift_acceleration),
         "--regrasp-approach-velocity", str(args.regrasp_approach_velocity),
         "--regrasp-approach-acceleration", str(args.regrasp_approach_acceleration),
+        "--regrasp-reset-joints-deg", str(args.regrasp_reset_joints_deg),
+        "--regrasp-reset-joint-velocity", str(args.regrasp_reset_joint_velocity),
+        "--regrasp-reset-joint-acceleration", str(args.regrasp_reset_joint_acceleration),
         "--press-min-transit-z-m", str(args.press_min_transit_z_m),
         "--press-pre-lift-m", str(args.press_pre_lift_m),
         "--press-transit-height-m", str(args.press_transit_height_m),
@@ -324,11 +414,25 @@ def main() -> int:
         "--move-release-offset-x-m", str(args.move_release_offset_x_m),
         "--move-release-offset-y-m", str(args.move_release_offset_y_m),
         "--move-release-offset-z-m", str(args.move_release_offset_z_m),
+        "--cup-pre-from-place-x-offset-m", str(args.cup_pre_from_place_x_offset_m),
+        "--cup-pre-from-place-z-offset-m", str(args.cup_pre_from_place_z_offset_m),
+        "--generated-cup-pre-max-joint-delta-deg", str(args.generated_cup_pre_max_joint_delta_deg),
         "--regrasp-retreat-x-m", str(args.regrasp_retreat_x_m),
         "--regrasp-retreat-y-m", str(args.regrasp_retreat_y_m),
         "--post-press-safe-lift-z-m", str(args.post_press_safe_lift_z_m),
+        "--start-safe-lift-z-m", str(args.start_safe_lift_z_m),
+        "--min-allowed-tcp-z-m", str(args.min_allowed_tcp_z_m),
+        "--release-approach-lift-m", str(args.release_approach_lift_m),
+        "--release-start-safe-lift-m", str(args.release_start_safe_lift_m),
+        "--release-min-transit-z-m", str(args.release_min_transit_z_m),
+        "--post-release-safe-lift-m", str(args.post_release_safe_lift_m),
         "--regrasp-rear-entry-offset-x-m", str(args.regrasp_rear_entry_offset_x_m),
         "--regrasp-rear-entry-offset-y-m", str(args.regrasp_rear_entry_offset_y_m),
+        "--final-regrasp-extra-x-offset-m", str(args.final_regrasp_extra_x_offset_m),
+        "--final-regrasp-extra-y-offset-m", str(args.final_regrasp_extra_y_offset_m),
+        "--final-regrasp-extra-z-offset-m", str(args.final_regrasp_extra_z_offset_m),
+        "--final-regrasp-grasp-width-m", str(args.final_regrasp_grasp_width_m),
+        "--final-regrasp-force-n", str(args.final_regrasp_force_n),
         "--press-line-velocity", str(args.press_line_velocity),
         "--press-line-acceleration", str(args.press_line_acceleration),
         "--press-travel-velocity", str(args.press_travel_velocity),
@@ -344,6 +448,16 @@ def main() -> int:
         "--press-lock-contact-joints", str(args.press_lock_contact_joints),
         "--gripper-open-settle-seconds", str(args.gripper_open_settle_seconds),
         "--gripper-settle-seconds", str(args.gripper_settle_seconds),
+        "--cup-holder-place-final-z-offset-m", str(args.cup_holder_place_final_z_offset_m),
+        "--cup-holder-place-final-y-offset-m", str(args.cup_holder_place_final_y_offset_m),
+        "--cup-holder-approach-velocity", str(args.cup_holder_approach_velocity),
+        "--cup-holder-approach-acceleration", str(args.cup_holder_approach_acceleration),
+        "--cup-holder-place-velocity", str(args.cup_holder_place_velocity),
+        "--cup-holder-place-acceleration", str(args.cup_holder_place_acceleration),
+        "--cup-holder-retreat-velocity", str(args.cup_holder_retreat_velocity),
+        "--cup-holder-retreat-acceleration", str(args.cup_holder_retreat_acceleration),
+        "--cup-holder-timeout-sec", str(args.cup_holder_timeout_sec),
+        "--cup-holder-target-tolerance-mm", str(args.cup_holder_target_tolerance_mm),
         "--wait-service-sec", str(args.wait_service_sec),
         "--pose-read-retries", str(args.pose_read_retries),
         "--pose-read-retry-sleep-sec", str(args.pose_read_retry_sleep_sec),
@@ -352,9 +466,41 @@ def main() -> int:
         "--safe-lift-joint-fallback",
         "--no-integrated-regrasp-fallback-subprocess",
     ]
+    sequence_extra_args.append(
+        "--force-start-safe-lift" if args.force_start_safe_lift else "--no-force-start-safe-lift"
+    )
+    sequence_extra_args.append(
+        "--skip-release-pre" if args.skip_release_pre else "--no-skip-release-pre"
+    )
+    sequence_extra_args.append(
+        "--use-cup-common-pre" if args.use_cup_common_pre else "--no-use-cup-common-pre"
+    )
+    sequence_extra_args.append(
+        "--use-release-staging" if args.use_release_staging else "--no-use-release-staging"
+    )
+    sequence_extra_args.append(
+        "--place-cup-holder-after-sequence"
+        if args.place_cup_holder_after_sequence
+        else "--no-place-cup-holder-after-sequence"
+    )
+    for flag, value in (
+        ("--release-staging-x-m", args.release_staging_x_m),
+        ("--release-staging-y-m", args.release_staging_y_m),
+        ("--release-staging-z-m", args.release_staging_z_m),
+    ):
+        if str(value).strip():
+            sequence_extra_args += [flag, str(value).strip()]
     sequence_extra_args.append(
         "--press-reset-before-press" if args.press_reset_before_press else "--no-press-reset-before-press"
     )
+    sequence_extra_args.append(
+        "--press-contact-use-joint-move"
+        if args.press_contact_use_joint_move
+        else "--no-press-contact-use-joint-move"
+    )
+    sequence_extra_args.append(
+        "--regrasp-reset-before-cup" if args.regrasp_reset_before_cup else "--no-regrasp-reset-before-cup"
+    )
     if args.allow_tcp_set_failure:
         sequence_extra_args.append("--allow-tcp-set-failure")
     if args.force_cartesian_press:
diff --git a/tools/run/run_color_scan_stage.sh b/tools/run/run_color_scan_stage.sh
new file mode 100755
index 0000000..46013d2
--- /dev/null
+++ b/tools/run/run_color_scan_stage.sh
@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+# 색상 스캔 단계: color_scan_pose(joints 0,10,32,0,100,90)로 이동한 뒤 디스펜서 색상을 스캔한다.
+# dispenser_color_scan_ros.sh가 outputs/dispenser_color_map.json을 새로 만들어야
+# run_color_recipe_sequence.py가 진행되므로, 이 단계는 레시피 전에 반드시 성공해야 한다.
+
+cd /home/ssu/Azas && source /opt/ros/humble/setup.bash && mkdir -p /tmp/azas_ros_logs && export ROS_LOG_DIR=/tmp/azas_ros_logs && export ROS_DOMAIN_ID=${ROS_DOMAIN_ID:-9} && export ROS_LOCALHOST_ONLY=${ROS_LOCALHOST_ONLY:-0} && export FASTDDS_BUILTIN_TRANSPORTS=${FASTDDS_BUILTIN_TRANSPORTS:-UDPv4} && if [ -f /home/ssu/ws_moveit/install/setup.bash ]; then source /home/ssu/ws_moveit/install/setup.bash; fi && if [ -f /home/ssu/ros2_ws/install/setup.bash ]; then source /home/ssu/ros2_ws/install/setup.bash; fi && if [ -f /home/ssu/Azas/install/setup.bash ]; then source /home/ssu/Azas/install/setup.bash; else source /home/ssu/Azas/install/local_setup.bash; fi && export PYTHONPATH=/home/ssu/Azas/tools/run/python_compat:${PYTHONPATH:-} && python3 tools/run/direct_movej_joints.py --service-prefix dsr01 --j1 0 --j2 10 --j3 32 --j4 0 --j5 100 --j6 90 --velocity 30 --acceleration 30 --timeout-sec 60 --motion-timeout-sec 120 --execute --confirm ENABLE_DIRECT_MOVEJ && tools/run/dispenser_color_scan_ros.sh
diff --git a/tools/run/run_course_dispenser_press_cycle_rviz.sh b/tools/run/run_course_dispenser_press_cycle_rviz.sh
index 721671b..9b16f9c 100755
--- a/tools/run/run_course_dispenser_press_cycle_rviz.sh
+++ b/tools/run/run_course_dispenser_press_cycle_rviz.sh
@@ -311,10 +311,10 @@ fi
 
 if [[ "${SHOW_LINK6_GRIPPER}" == "1" || "${SHOW_LINK6_GRIPPER}" == "true" ]]; then
   ros2 launch azas_bringup rg2_link6_tcp.launch.py \
-    publish_gripper_collision:=true \
+    publish_gripper_collision:=false \
     >"${LOG_DIR}/rg2_link6_tcp.log" 2>&1 &
   PIDS+=("$!")
-  echo "[Azas] SHOW_LINK6_GRIPPER=${SHOW_LINK6_GRIPPER}: publishing RG2 link_6 TF/markers on /azas/link6_gripper/markers."
+  echo "[Azas] SHOW_LINK6_GRIPPER=${SHOW_LINK6_GRIPPER}: publishing RG2 link_6 TF only; MoveIt uses the mesh-based RG2 URDF."
 fi
 
 if [[ "${DISPENSER_COLLISION_OBJECTS}" == "0" || "${DISPENSER_COLLISION_OBJECTS}" == "false" ]]; then
diff --git a/tools/run/run_human_hand_detection.sh b/tools/run/run_human_hand_detection.sh
new file mode 100755
index 0000000..8feea5a
--- /dev/null
+++ b/tools/run/run_human_hand_detection.sh
@@ -0,0 +1,19 @@
+#!/usr/bin/env bash
+# Perception-only human hand detection for the post-shake handover plan.
+# Publishes /azas/human_hand_detection (PointStamped, camera optical frame),
+# /azas/human_hand_detection/status (JSON), and an overlay image.
+# This NEVER sends a robot motion command (gate: no_motion_hri_perception_only).
+# Note: no `set -u`; ROS setup.bash references unset vars.
+set -eo pipefail
+
+ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
+
+source /opt/ros/humble/setup.bash
+if [[ -f "${ROOT_DIR}/install/setup.bash" ]]; then
+  source "${ROOT_DIR}/install/setup.bash"
+fi
+
+export ROS_DOMAIN_ID="${ROS_DOMAIN_ID:-9}"
+export ROS_LOCALHOST_ONLY="${ROS_LOCALHOST_ONLY:-0}"
+
+exec python3 "${ROOT_DIR}/tools/perception/human_hand_detection_node.py" "$@"
diff --git a/tools/run/run_kang_lid_grip_close_direct.sh b/tools/run/run_kang_lid_grip_close_direct.sh
index a323a7d..fec0f5d 100755
--- a/tools/run/run_kang_lid_grip_close_direct.sh
+++ b/tools/run/run_kang_lid_grip_close_direct.sh
@@ -10,10 +10,10 @@ ARUCO_DICTIONARY="${ARUCO_DICTIONARY:-DICT_4X4_50}"
 ARUCO_MARKER_ID="${ARUCO_MARKER_ID:-14}"
 ARUCO_FALLBACK_MARKERS="${ARUCO_FALLBACK_MARKERS:-}"
 ARUCO_MARKER_LENGTH_M="${ARUCO_MARKER_LENGTH_M:-0.03}"
-ROS_DOMAIN_ID="${ROS_DOMAIN_ID:-9}"
+ROS_DOMAIN_ID="${LID_ROS_DOMAIN_ID:-${ROS_DOMAIN_ID:-9}}"
 ROS_LOCALHOST_ONLY="${ROS_LOCALHOST_ONLY:-0}"
 FASTDDS_BUILTIN_TRANSPORTS="${FASTDDS_BUILTIN_TRANSPORTS:-UDPv4}"
-MOVE_TO_LID_VIEW_POSE="${MOVE_TO_LID_VIEW_POSE:-true}"
+MOVE_TO_LID_VIEW_POSE="${MOVE_TO_LID_VIEW_POSE:-false}"
 
 cd "${ROOT}"
 
@@ -46,6 +46,7 @@ echo "[Azas] OpenCV window: confirm lid ArUco, then press p. Quit with q/Esc."
 echo "[Azas] service_prefix=${SERVICE_PREFIX} DISPLAY=${DISPLAY} XAUTHORITY=${XAUTHORITY}"
 echo "[Azas] ROS_DOMAIN_ID=${ROS_DOMAIN_ID} ROS_LOCALHOST_ONLY=${ROS_LOCALHOST_ONLY} FASTDDS_BUILTIN_TRANSPORTS=${FASTDDS_BUILTIN_TRANSPORTS}"
 echo "[Azas] aruco=${ARUCO_DICTIONARY}:${ARUCO_MARKER_ID} fallback=${ARUCO_FALLBACK_MARKERS} length_m=${ARUCO_MARKER_LENGTH_M}"
+echo "[Azas] note: use_j6_yaw_for_pick/pick_j6_* are not supported by this Azas launch; using supported ArUco-axis orientation parameters."
 
 if [[ ! -f "${MODEL_PATH}" ]]; then
   echo "[Azas][WARN] model_path not found: ${MODEL_PATH}"
@@ -78,32 +79,36 @@ launch_args=(
   aruco_dictionary:="${ARUCO_DICTIONARY}" aruco_marker_id:="${ARUCO_MARKER_ID}" \
   aruco_marker_length_m:="${ARUCO_MARKER_LENGTH_M}" \
   use_aruco_axis_for_orientation:=true aruco_finger_axis_quarter_turns:=0 \
-  use_lid_pose_yaw_for_pick:=true lid_pose_yaw_axis:=y lid_pose_yaw_offset_deg:=0.0 lid_pose_yaw_equivalence_deg:=180.0 \
-  visual_refine_before_grasp:=true visual_refine_sample_count:=5 visual_refine_timeout_sec:=3.0 visual_refine_max_yaw_std_deg:=3.0 \
+  use_lid_pose_yaw_for_pick:=false lid_pose_yaw_axis:=y lid_pose_yaw_offset_deg:=0.0 lid_pose_yaw_equivalence_deg:=360.0 \
+  visual_refine_before_grasp:=true visual_refine_sample_count:=5 visual_refine_timeout_sec:=3.0 visual_refine_max_yaw_std_deg:=5.0 \
   visual_refine_max_position_std_m:=0.005 visual_refine_apply_xy:=true visual_refine_apply_yaw:=true visual_refine_fallback_to_initial_plan:=true \
   enable_hardware:=true hardware_confirm:=ENABLE_REAL_ROBOT_MOTION allow_service_control_without_moveit:=true service_prefix:="${SERVICE_PREFIX}" \
-  approach_lid_with_movej:=true approach_movej_velocity:=20.0 approach_movej_acceleration:=20.0 \
-  lid_overhead_approach_enabled:=true lid_overhead_min_z_m:=0.260 \
+  approach_lid_with_movej:=false approach_movej_velocity:=20.0 approach_movej_acceleration:=20.0 \
+  lid_overhead_approach_enabled:=false lid_overhead_min_z_m:=0.260 \
   rx:=108.41 ry:=-176.32 rz:=175.98 offset_axis:=base_z surface_offset_m:=0.0 \
-  tcp_grasp_offset_x_m:=0.0 tcp_grasp_offset_y_m:=0.0 tcp_grasp_offset_z_m:=0.160 min_grasp_z_m:=0.180 \
-  approach_offset_m:=0.08 min_approach_z_m:=0.260 lift_offset_m:=0.10 settle_seconds_before_grasp:=0.5 hold_seconds_after_grasp:=3.0 \
-  line_velocity:=15.0 line_acceleration:=8.0 move_timeout_sec:=90.0 \
+  tcp_grasp_offset_x_m:=0.0 tcp_grasp_offset_y_m:=0.0 tcp_grasp_offset_z_m:=-0.040 min_grasp_z_m:=0.025 \
+  approach_offset_m:=0.08 min_approach_z_m:=0.0 lift_offset_m:=0.10 settle_seconds_before_grasp:=0.5 hold_seconds_after_grasp:=3.0 \
+  line_velocity:=30.0 line_acceleration:=10.0 move_timeout_sec:=90.0 \
   enable_gripper_service_calls:=true gripper_set_service:=/jarvis/rg2/set_width \
   gripper_preopen_width_m:=0.110 gripper_grasp_width_m:=0.020 gripper_force_n:=12.0 \
   continue_after_gripper_grasp_failure:=true gripper_grasp_failure_wait_sec:=2.0 \
   enable_lid_twist_after_grasp:=true \
   lid_twist_target_x_m:=0.422959106 lid_twist_target_y_m:=0.223224869 lid_twist_target_z_m:=0.166827988 \
   lid_twist_rx:=73.901489 lid_twist_ry:=-178.542740 lid_twist_rz:=117.385612 \
-  lid_twist_transfer_clearance_m:=0.12 lid_twist_transfer_max_z_m:=0.60 \
-  lid_twist_use_force_control:=false lid_twist_force_rotation_mode:=j6 \
+  lid_twist_transfer_clearance_m:=0.20 lid_twist_transfer_max_z_m:=0.60 \
+  lid_twist_use_force_control:=false lid_twist_use_force_spiral:=true lid_twist_force_rotation_mode:=j6 \
+  lid_twist_down_force_n:=2.0 lid_twist_force_ref:=base lid_twist_force_service_timeout_sec:=20.0 \
+  lid_twist_force_settle_seconds:=0.2 lid_twist_force_release_time:=0.2 \
   lid_twist_preseat_periodic_before_turn:=true \
   lid_twist_preseat_periodic_x_amp_mm:=0.0 lid_twist_preseat_periodic_y_amp_mm:=0.0 lid_twist_preseat_periodic_z_amp_mm:=1.0 \
   lid_twist_preseat_periodic_rx_amp_deg:=0.0 lid_twist_preseat_periodic_ry_amp_deg:=0.0 lid_twist_preseat_periodic_rz_amp_deg:=10.0 \
   lid_twist_preseat_periodic_period_sec:=3.6 lid_twist_preseat_periodic_acc_time_sec:=1.0 lid_twist_preseat_periodic_repeat:=2 \
-  lid_twist_preseat_periodic_ref:=tool lid_twist_rz_delta_deg:=300.0 lid_twist_turn_step_deg:=50.0 \
-  lid_twist_release_lift_m:=0.03 lid_twist_min_z_m:=0.140 lid_twist_max_z_m:=0.220 \
-  lid_twist_transfer_velocity:=25.0 lid_twist_press_velocity:=5.0 lid_twist_turn_velocity:=30.0 lid_twist_acceleration:=15.0 \
-  lid_twist_hold_seconds_before_turn:=0.0 lid_twist_hold_seconds_after_turn:=0.5
+  lid_twist_preseat_periodic_ref:=tool lid_twist_rz_delta_deg:=360.0 lid_twist_turn_step_deg:=60.0 \
+  lid_twist_release_lift_m:=0.03 lid_twist_min_z_m:=0.140 lid_twist_max_z_m:=0.260 \
+  lid_twist_transfer_velocity:=25.0 lid_twist_press_velocity:=10.0 lid_twist_turn_velocity:=40.0 lid_twist_acceleration:=15.0 \
+  lid_twist_hold_seconds_before_turn:=0.2 lid_twist_hold_seconds_after_turn:=0.5 \
+  lid_twist_compliance_x_stiffness:=3000.0 lid_twist_compliance_y_stiffness:=3000.0 lid_twist_compliance_z_stiffness:=300.0 \
+  lid_twist_compliance_rx_stiffness:=200.0 lid_twist_compliance_ry_stiffness:=200.0 lid_twist_compliance_rz_stiffness:=200.0
 )
 
 if [[ -n "${ARUCO_FALLBACK_MARKERS}" ]]; then
diff --git a/tools/run/run_lid_close_then_shake_chain.sh b/tools/run/run_lid_close_then_shake_chain.sh
new file mode 100755
index 0000000..e87027e
--- /dev/null
+++ b/tools/run/run_lid_close_then_shake_chain.sh
@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+# 디스펜서 레시피 완료 후 체인: 뚜껑 닫기(ArUco 성공 감시) -> 컵홀더 재픽업 -> 쉐이킹 -> 카메라 포즈 복귀.
+# robot_pipeline_control_server.py chain_shake_after_lid_command()가 생성하는 패널 체인과 동일한 명령을
+# auto_cup_flow_router가 직접 실행할 수 있도록 스크립트로 고정한 것이다.
+
+( cd /home/ssu/Azas && SERVICE_PREFIX=dsr01 DISPLAY=${DISPLAY:-:0} XAUTHORITY=${XAUTHORITY:-/run/user/1000/gdm/Xauthority} MOVE_TO_LID_VIEW_POSE=true bash /home/ssu/Azas/tools/run/run_kang_lid_grip_close_direct.sh ) & lid_pid=$!; ( cd /home/ssu/Azas && source /opt/ros/humble/setup.bash && mkdir -p /tmp/azas_ros_logs && export ROS_LOG_DIR=/tmp/azas_ros_logs && export ROS_DOMAIN_ID=${ROS_DOMAIN_ID:-9} && export ROS_LOCALHOST_ONLY=${ROS_LOCALHOST_ONLY:-0} && export FASTDDS_BUILTIN_TRANSPORTS=${FASTDDS_BUILTIN_TRANSPORTS:-UDPv4} && if [ -f /home/ssu/ws_moveit/install/setup.bash ]; then source /home/ssu/ws_moveit/install/setup.bash; fi && if [ -f /home/ssu/ros2_ws/install/setup.bash ]; then source /home/ssu/ros2_ws/install/setup.bash; fi && if [ -f /home/ssu/Azas/install/setup.bash ]; then source /home/ssu/Azas/install/setup.bash; else source /home/ssu/Azas/install/local_setup.bash; fi && export PYTHONPATH=/home/ssu/Azas/tools/run/python_compat:${PYTHONPATH:-} && python3 /home/ssu/Azas/tools/run/wait_for_lid_grip_status.py --timeout-sec 900 --success-status motion_sequence_requested ) & wait_pid=$!; while true; do if ! kill -0 ${wait_pid} 2>/dev/null; then wait ${wait_pid}; wait_rc=$?; break; fi; if ! kill -0 ${lid_pid} 2>/dev/null; then wait ${lid_pid}; lid_rc=$?; sleep 1; if ! kill -0 ${wait_pid} 2>/dev/null; then wait ${wait_pid}; wait_rc=$?; break; fi; echo '[Azas] lid_grip_close launch exited before ArUco success status; shake chain blocked.'; kill -TERM ${wait_pid} 2>/dev/null || true; wait ${wait_pid} 2>/dev/null || true; if [ ${lid_rc} -eq 0 ]; then exit 1; else exit ${lid_rc}; fi; fi; sleep 1; done; kill -TERM ${lid_pid} 2>/dev/null || true; wait ${lid_pid} 2>/dev/null || true; if [ ${wait_rc} -eq 0 ]; then echo '[Azas] ArUco lid_grip_close 성공 status 확인 -> 컵홀더 컵 다시 잡기 후 쉐이킹으로 바로 넘어갑니다.'; echo '[Azas] auto_holder_pick_then_shake=true'; cd /home/ssu/Azas && source /opt/ros/humble/setup.bash && mkdir -p /tmp/azas_ros_logs && export ROS_LOG_DIR=/tmp/azas_ros_logs && export ROS_DOMAIN_ID=${ROS_DOMAIN_ID:-9} && export ROS_LOCALHOST_ONLY=${ROS_LOCALHOST_ONLY:-0} && export FASTDDS_BUILTIN_TRANSPORTS=${FASTDDS_BUILTIN_TRANSPORTS:-UDPv4} && if [ -f /home/ssu/ws_moveit/install/setup.bash ]; then source /home/ssu/ws_moveit/install/setup.bash; fi && if [ -f /home/ssu/ros2_ws/install/setup.bash ]; then source /home/ssu/ros2_ws/install/setup.bash; fi && if [ -f /home/ssu/Azas/install/setup.bash ]; then source /home/ssu/Azas/install/setup.bash; else source /home/ssu/Azas/install/local_setup.bash; fi && export PYTHONPATH=/home/ssu/Azas/tools/run/python_compat:${PYTHONPATH:-} && echo '[Azas] SHAKE START: 컵홀더에 놓인 닫힌 컵을 측정 pose로 다시 side-grip 픽업한 뒤 흔듭니다.' && echo '[Azas] 순서: RG2 open -> 컵홀더 retreat 접근 -> holder final pose에서 soft grasp -> holder lift -> 관절 쉐이킹.' && echo '[Azas] 주의: 컵 좌표를 새로 만들지 않고 calibration.yaml cup_holder.side_grip_place 측정값만 사용합니다.' && python3 tools/run/pick_from_cup_holder_side_grip.py --service-prefix dsr01 --config /home/ssu/Azas/install/azas_bringup/share/azas_bringup/config/calibration.yaml --approach-velocity 12.0 --approach-acceleration 16.0 --descend-velocity 6.0 --descend-acceleration 10.0 --lift-velocity 12.0 --lift-acceleration 16.0 --place-final-z-offset-m -0.020 --timeout-sec 90.0 --target-tolerance-mm 12.0 --verify-timeout-sec 45.0 --ikin-timeout-sec 20.0 --ikin-retries 2 --gripper-grasp-width-m 0.068 --gripper-force-n 35.0 --post-grasp-settle-sec 0.8 --z-max 0.28 --execute --confirm ENABLE_CUP_HOLDER_PICK && timeout 5s python3 -m azas_motion.tumbler_collision_scene_node --ros-args -p action:=remove_world -p object_id:=tumbler_in_holder -p dispenser_id:=1 -p publish_once:=true && timeout 5s python3 -m azas_motion.tumbler_collision_scene_node --ros-args -p action:=attach -p object_id:=carried_tumbler -p dispenser_id:=1 -p publish_once:=true && SERVICE_PREFIX=dsr01 GRASPED_CUP_TEST_MODE=true SKIP_CUP_HOLDER_PICK=true REQUIRE_ROBOT_STANDBY=true SHAKE_CONTROL_MODE=joint SHAKE_CYCLES=3 JOINT_SHAKE_BASE_J1_DEG=0.0 JOINT_SHAKE_BASE_J2_DEG=-35.0 JOINT_SHAKE_BASE_J3_DEG=50.0 JOINT_SHAKE_BASE_J4_DEG=0.0 JOINT_SHAKE_BASE_J5_DEG=70.0 JOINT_SHAKE_BASE_J6_DEG=0.0 JOINT_SHAKE_J3_AMPLITUDE_DEG=0.0 JOINT_SHAKE_J4_AMPLITUDE_DEG=18.0 JOINT_SHAKE_J5_AMPLITUDE_DEG=20.0 JOINT_SHAKE_J6_AMPLITUDE_DEG=24.0 JOINT_SHAKE_J1_MIN_DEG=-20.0 JOINT_SHAKE_J1_MAX_DEG=5.0 JOINT_SHAKE_J2_MIN_DEG=-80.0 JOINT_SHAKE_J2_MAX_DEG=5.0 JOINT_SHAKE_J3_MIN_DEG=0.0 JOINT_SHAKE_J3_MAX_DEG=135.0 JOINT_SHAKE_MAX_SINGLE_DELTA_DEG=75.0 ENFORCE_WRIST_JOINT_LIMITS=false WRIST_MIN_DEG=-135.0 WRIST_MAX_DEG=135.0 JOINT5_MIN_DEG=40.0 JOINT5_MAX_DEG=100.0 APPROACH_JOINT_VELOCITY=18.0 APPROACH_JOINT_ACCELERATION=22.0 APPROACH_JOINT_TIME=2.6 SHAKE_JOINT_VELOCITY=90.0 SHAKE_JOINT_ACCELERATION=120.0 SHAKE_JOINT_TIME=0.0 JOINT_SHAKE_PEAK_VELOCITY_LIMIT_DEG_S=130.0 VERIFY_JOINT_TARGETS=true JOINT_TARGET_TOLERANCE_DEG=8.0 JOINT_TARGET_WAIT_EXTRA_SEC=3.0 JOINT_TARGET_POLL_SEC=0.05 REQUIRE_STATE_VALIDITY_FOR_JOINT_SHAKE=true tools/run/run_rule_based_shake_real.sh && echo '[Azas] SHAKE DONE: 손 검출/핸드오버를 위해 카메라 포즈로 복귀합니다 (컵 파지 유지).' && python3 tools/run/direct_movej_joints.py --service-prefix dsr01 --j1 3.0 --j2 -12.7 --j3 44.0 --j4 -9.0 --j5 133.0 --j6 90.0 --velocity 15 --acceleration 15 --j5-min-deg -150 --j5-max-deg 150 --timeout-sec 60 --motion-timeout-sec 120 --execute --confirm ENABLE_DIRECT_MOVEJ; else echo '[Azas] ArUco lid_grip_close 실패/타임아웃 -> 컵홀더 재픽업/쉐이킹을 건너뜁니다.'; exit ${wait_rc}; fi
diff --git a/tools/run/run_measured_dispenser_recipe_sequence.py b/tools/run/run_measured_dispenser_recipe_sequence.py
index 723af70..94d7f73 100755
--- a/tools/run/run_measured_dispenser_recipe_sequence.py
+++ b/tools/run/run_measured_dispenser_recipe_sequence.py
@@ -2,8 +2,8 @@
 """Run an ordered measured-dispenser recipe loop.
 
 For each dispenser ID this composes measured rule-based primitives:
-  move/release cup at DISP_PRE/DISP_PLACE -> measured PRESS_CONTACT FK
-  -> generated Z-only PRESS_PRE -> measured contact -> Z-only pump stroke
+  move/release cup at DISP_PRE/DISP_PLACE -> measured PRESS_CONTACT
+  -> generated CONTACT_ENTRY_LIFT -> Z-only pump overdrive
   -> re-grasp/lift cup at DISP_PLACE.
 
 All cup/dispenser positions come from measured calibration data.  This runner
@@ -61,6 +61,7 @@
     "reteach_required",
     "확인 필요",
 }
+INVALID_CUP_PLACE_STATUSES = INVALID_PRESS_CONTACT_STATUSES
 
 DR_BASE = 0
 MOVE_MODE_ABSOLUTE = 0
@@ -76,12 +77,23 @@ def angular_delta_deg(target: float, current: float) -> float:
 
 def equivalent_angle_near_current_deg(target: float, current: float, *, max_abs: float) -> float:
     """Choose the equivalent joint angle closest to the current controller reading."""
-    candidates = [float(target) + 360.0 * step for step in range(-2, 3)]
+    target_value = float(target)
+    current_value = float(current)
+    center_step = round((current_value - target_value) / 360.0)
+    candidates = [target_value + 360.0 * (center_step + step) for step in range(-2, 3)]
+    modulo = ((target_value + 180.0) % 360.0) - 180.0
+    candidates.extend(
+        [
+            modulo,
+            modulo + 360.0,
+            modulo - 360.0,
+        ]
+    )
     if max_abs > 0.0:
         bounded = [candidate for candidate in candidates if abs(candidate) <= max_abs]
         if bounded:
             candidates = bounded
-    return min(candidates, key=lambda candidate: abs(candidate - float(current)))
+    return min(candidates, key=lambda candidate: abs(candidate - current_value))
 
 
 def parse_dispenser_ids(raw: str) -> list[str]:
@@ -177,6 +189,19 @@ def ensure_press_contact_enabled(dispenser_id: str, block: dict[str, Any]) -> No
         )
 
 
+def cup_place_status(block: dict[str, Any]) -> str:
+    return str(block.get("cup_place_status", "")).strip()
+
+
+def ensure_cup_place_enabled(dispenser_id: str, block: dict[str, Any]) -> None:
+    status = cup_place_status(block)
+    if status.lower() in INVALID_CUP_PLACE_STATUSES:
+        raise ValueError(
+            f"dispenser_outlets.{dispenser_id}.cup_place_joints_deg is marked "
+            f"{status!r}; refusing real cup place/re-grasp motion until DISP{dispenser_id} cup place is re-taught"
+        )
+
+
 def require_dispenser_press_contact_enabled(dispenser_id: str) -> None:
     data = yaml.safe_load(CALIBRATION_CONFIG.read_text(encoding="utf-8")) or {}
     outlets = data.get("dispenser_outlets") or {}
@@ -322,12 +347,67 @@ def load_press_pre_joints_deg(dispenser_id: str) -> list[float] | None:
     )
 
 
+def load_press_common_pre_joints_deg(dispenser_id: str) -> list[float] | None:
+    data = yaml.safe_load(CALIBRATION_CONFIG.read_text(encoding="utf-8")) or {}
+    outlets = data.get("dispenser_outlets") or {}
+    block = outlets.get(str(dispenser_id))
+    if not isinstance(block, dict):
+        raise ValueError(f"dispenser_outlets.{dispenser_id} is missing in {CALIBRATION_CONFIG}")
+    raw_joints = block.get("press_common_pre_joints_deg")
+    source_id = str(dispenser_id)
+    if raw_joints is None:
+        for candidate_id in sorted(
+            outlets,
+            key=lambda value: (0, int(value)) if str(value).isdigit() else (1, str(value)),
+        ):
+            candidate_block = outlets.get(str(candidate_id))
+            if isinstance(candidate_block, dict) and candidate_block.get("press_common_pre_joints_deg") is not None:
+                raw_joints = candidate_block.get("press_common_pre_joints_deg")
+                source_id = str(candidate_id)
+                break
+    if raw_joints is None:
+        return None
+    return numeric_list(
+        raw_joints,
+        f"dispenser_outlets.{source_id}.press_common_pre_joints_deg",
+        6,
+    )
+
+
+def load_cup_common_pre_joints_deg(dispenser_id: str) -> list[float] | None:
+    data = yaml.safe_load(CALIBRATION_CONFIG.read_text(encoding="utf-8")) or {}
+    outlets = data.get("dispenser_outlets") or {}
+    block = outlets.get(str(dispenser_id))
+    if not isinstance(block, dict):
+        raise ValueError(f"dispenser_outlets.{dispenser_id} is missing in {CALIBRATION_CONFIG}")
+    raw_joints = block.get("cup_common_pre_joints_deg")
+    source_id = str(dispenser_id)
+    if raw_joints is None:
+        for candidate_id in sorted(
+            outlets,
+            key=lambda value: (0, int(value)) if str(value).isdigit() else (1, str(value)),
+        ):
+            candidate_block = outlets.get(str(candidate_id))
+            if isinstance(candidate_block, dict) and candidate_block.get("cup_common_pre_joints_deg") is not None:
+                raw_joints = candidate_block.get("cup_common_pre_joints_deg")
+                source_id = str(candidate_id)
+                break
+    if raw_joints is None:
+        return None
+    return numeric_list(
+        raw_joints,
+        f"dispenser_outlets.{source_id}.cup_common_pre_joints_deg",
+        6,
+    )
+
+
 def load_cup_pre_place_joints_deg(dispenser_id: str) -> list[float] | None:
     data = yaml.safe_load(CALIBRATION_CONFIG.read_text(encoding="utf-8")) or {}
     outlets = data.get("dispenser_outlets") or {}
     block = outlets.get(str(dispenser_id))
     if not isinstance(block, dict):
         raise ValueError(f"dispenser_outlets.{dispenser_id} is missing in {CALIBRATION_CONFIG}")
+    ensure_cup_place_enabled(dispenser_id, block)
     raw_joints = block.get("cup_pre_place_joints_deg")
     if raw_joints is None:
         return None
@@ -344,6 +424,7 @@ def load_cup_place_joints_deg(dispenser_id: str) -> list[float] | None:
     block = outlets.get(str(dispenser_id))
     if not isinstance(block, dict):
         raise ValueError(f"dispenser_outlets.{dispenser_id} is missing in {CALIBRATION_CONFIG}")
+    ensure_cup_place_enabled(dispenser_id, block)
     raw_joints = block.get("cup_place_joints_deg")
     if raw_joints is None:
         return None
@@ -354,28 +435,98 @@ def load_cup_place_joints_deg(dispenser_id: str) -> list[float] | None:
     )
 
 
+def load_cup_holder_target_posx(name: str) -> list[float]:
+    data = yaml.safe_load(CALIBRATION_CONFIG.read_text(encoding="utf-8")) or {}
+    holder = data.get("cup_holder")
+    if not isinstance(holder, dict):
+        raise ValueError(f"cup_holder section is missing in {CALIBRATION_CONFIG}")
+    block = holder.get("side_grip_place")
+    if not isinstance(block, dict):
+        raise ValueError(f"cup_holder.side_grip_place section is missing in {CALIBRATION_CONFIG}")
+    xyz_m = numeric_list(
+        block.get(f"{name}_pose_xyz_m"),
+        f"cup_holder.side_grip_place.{name}_pose_xyz_m",
+        3,
+    )
+    rpy_rad = numeric_list(
+        block.get(f"{name}_pose_rpy_rad"),
+        f"cup_holder.side_grip_place.{name}_pose_rpy_rad",
+        3,
+    )
+    return [
+        xyz_m[0] * 1000.0,
+        xyz_m[1] * 1000.0,
+        xyz_m[2] * 1000.0,
+        math.degrees(rpy_rad[0]),
+        math.degrees(rpy_rad[1]),
+        math.degrees(rpy_rad[2]),
+    ]
+
+
 def format_joints_deg(joints: list[float]) -> str:
     return "[" + ", ".join(f"{value:.2f}" for value in joints) + "]"
 
 
 def print_dry_run_group_detail(args: argparse.Namespace, dispenser_id: str, press_count: int) -> None:
-    cup_pre = load_cup_pre_place_joints_deg(dispenser_id)
     cup_place = load_cup_place_joints_deg(dispenser_id)
-    if cup_pre is not None and cup_place is not None:
+    cup_common_pre = load_cup_common_pre_joints_deg(dispenser_id) if args.use_cup_common_pre else None
+    if args.skip_release_pre:
+        if cup_place is not None:
+            print(f"[Azas] DISP_PLACE={format_joints_deg(cup_place)}")
+        staging_step = "RELEASE_STAGING -> " if args.use_release_staging else ""
         print(
-            f"[PLAN] dispenser {dispenser_id}: cup DISP_PRE={format_joints_deg(cup_pre)} "
-            f"-> DISP_PLACE={format_joints_deg(cup_place)}"
+            f"[PLAN] dispenser {dispenser_id}: safe release (skip_release_pre) "
+            f"START_SAFE_LIFT(Z-only, >= {max(args.release_min_transit_z_m, 0.0):.3f}m) -> {staging_step}"
+            f"RELEASE_ABOVE(final+{max(args.release_approach_lift_m, 0.0) * 1000.0:.0f}mm) -> "
+            f"vertical RELEASE_FINAL -> OPEN -> "
+            f"POST_RELEASE_LIFT(+{max(args.post_release_safe_lift_m, 0.0) * 1000.0:.0f}mm)"
         )
+    elif cup_place is not None:
+        if cup_common_pre is not None:
+            print(f"[Azas] CUP_COMMON_PRE={format_joints_deg(cup_common_pre)}")
+        print(f"[Azas] DISP_PLACE={format_joints_deg(cup_place)}")
+        if cup_common_pre is not None:
+            print(f"[PLAN] dispenser {dispenser_id}: cup CUP_COMMON_PRE -> DISP_PLACE -> RELEASE")
+        else:
+            print(
+                f"[PLAN] dispenser {dispenser_id}: cup generated DISP_PRE "
+                f"(DISP_PLACE X{args.cup_pre_from_place_x_offset_m * 1000.0:+.0f}mm "
+                f"Z{args.cup_pre_from_place_z_offset_m * 1000.0:+.0f}mm) "
+                "-> DISP_PLACE -> RELEASE"
+            )
     else:
         print(f"[PLAN] dispenser {dispenser_id}: cup placement fallback=front_hold_poses")
 
     press_contact = load_press_ready_joints_deg(dispenser_id)
+    press_pre = (
+        load_press_pre_joints_deg(dispenser_id)
+        if press_contact is not None and not args.skip_measured_press_pre
+        else None
+    )
+    press_common_pre = load_press_common_pre_joints_deg(dispenser_id) if press_contact is not None else None
     z_overdrive_mm = (max(args.press_depth_m, 0.0) + max(args.press_extra_depth_m, 0.0)) * 1000.0
-    if press_contact is not None:
+    if press_contact is not None and press_pre is not None and not args.skip_measured_press_pre:
+        print(f"[Azas] PRESS_PRE={format_joints_deg(press_pre)}")
+        print(f"[Azas] PRESS_CONTACT={format_joints_deg(press_contact)}")
+        print(
+            f"[PLAN] dispenser {dispenser_id}: press PRESS_PRE "
+            f"-> CONTACT_ENTRY_LIFT +{max(args.press_contact_entry_lift_m, 0.0) * 1000.0:.1f}mm -> PRESS_CONTACT "
+            f"-> PRESS_Z_OVERDRIVE {z_overdrive_mm:.1f}mm -> PRESS_CONTACT -> PRESS_PRE x{press_count}"
+        )
+    elif press_contact is not None:
+        if args.press_reset_before_press and press_common_pre is not None:
+            print(f"[Azas] PRESS_COMMON_PRE={format_joints_deg(press_common_pre)}")
+        print(f"[Azas] PRESS_CONTACT={format_joints_deg(press_contact)}")
+        if args.press_reset_before_press:
+            pre_step = "PRESS_COMMON_PRE -> " if press_common_pre is not None else "PRESS_RESET_HOME -> "
+        else:
+            pre_step = ""
         print(
-            f"[PLAN] dispenser {dispenser_id}: press CONTACT={format_joints_deg(press_contact)} "
-            f"-> generated PRE=CONTACT+Z{max(args.press_contact_entry_lift_m, 0.0) * 1000.0:.1f}mm "
-            f"-> PRESS=CONTACT-Z{z_overdrive_mm:.1f}mm x{press_count}"
+            f"[PLAN] dispenser {dispenser_id}: press {pre_step}CONTACT_ENTRY_LIFT "
+            f"(CONTACT+Z{max(args.press_contact_entry_lift_m, 0.0) * 1000.0:.1f}mm) "
+            f"-> PRESS_CONTACT -> "
+            f"(PRESS_Z_OVERDRIVE {z_overdrive_mm:.1f}mm -> PRESS_CONTACT) x{press_count} "
+            "-> POST_PRESS_SAFE_LIFT"
         )
     else:
         press_xyz_m, press_rpy_deg = load_press_pose(dispenser_id)
@@ -703,17 +854,182 @@ def move_posx_joint_fallback(
         label: str,
         velocity: float,
         acceleration: float,
+        verify_tolerance_mm: float | None = None,
+        max_joint_delta_deg: float | None = None,
     ) -> None:
+        self.validate_cartesian_target_z(posx_mm_deg, label=label)
         joints_deg = self.ikin_posj(posx_mm_deg, label=f"{label} IK joint fallback")
         joints_deg = self.normalize_ik_joints_near_current(joints_deg, label=label)
-        self.validate_ik_fallback_joints(joints_deg, label=label)
+        self.validate_ik_fallback_joints(joints_deg, label=label, max_joint_delta_deg=max_joint_delta_deg)
         self.movej(
             joints_deg,
             label=f"{label} IK MoveJoint fallback",
             velocity=velocity,
             acceleration=acceleration,
         )
-        self.wait_for_target(posx_mm_deg, label=f"{label} IK MoveJoint fallback posx")
+        self.wait_for_target(
+            posx_mm_deg,
+            label=f"{label} IK MoveJoint fallback posx",
+            tolerance_mm=verify_tolerance_mm,
+        )
+
+    def measured_cup_place_posx_with_release_offset(self, joints_deg: list[float], *, label: str) -> list[float]:
+        posx = self.fkin_posx(joints_deg, label=f"{label} measured FK")
+        adjusted = list(posx)
+        adjusted[0] += self.args.move_release_offset_x_m * 1000.0
+        adjusted[1] += self.args.move_release_offset_y_m * 1000.0
+        adjusted[2] += self.args.move_release_offset_z_m * 1000.0
+        print(
+            "[Azas] "
+            f"{label}: applying measured cup-place offset "
+            f"dx={self.args.move_release_offset_x_m * 1000.0:.1f}mm "
+            f"dy={self.args.move_release_offset_y_m * 1000.0:.1f}mm "
+            f"dz={self.args.move_release_offset_z_m * 1000.0:.1f}mm "
+            f"target_posx=[{adjusted[0]:.1f}, {adjusted[1]:.1f}, {adjusted[2]:.1f}, "
+            f"{adjusted[3]:.1f}, {adjusted[4]:.1f}, {adjusted[5]:.1f}]"
+        )
+        return adjusted
+
+    def move_measured_cup_place_with_offset(
+        self,
+        joints_deg: list[float],
+        *,
+        label: str,
+        velocity: float,
+        acceleration: float,
+    ) -> None:
+        if (
+            abs(self.args.move_release_offset_x_m) <= 1e-6
+            and abs(self.args.move_release_offset_y_m) <= 1e-6
+            and abs(self.args.move_release_offset_z_m) <= 1e-6
+        ):
+            joints_deg = self.normalize_joints_near_current(joints_deg, label=label)
+            self.movej(joints_deg, label=label, velocity=velocity, acceleration=acceleration)
+            return
+        target = self.measured_cup_place_posx_with_release_offset(joints_deg, label=label)
+        self.move_posx_joint_fallback(
+            target,
+            label=f"{label} with release offset",
+            velocity=velocity,
+            acceleration=acceleration,
+        )
+
+    def move_measured_cup_place_via_high_entry(
+        self,
+        joints_deg: list[float],
+        *,
+        dispenser_id: str,
+    ) -> None:
+        final_target = self.measured_cup_place_posx_with_release_offset(
+            joints_deg,
+            label=f"move to measured DISP{dispenser_id}_PLACE cup-place joints",
+        )
+        high_target = list(final_target)
+        desired_high_z = max(
+            final_target[2] + max(self.args.move_prehold_offset_z_m, 0.0) * 1000.0,
+            max(self.args.regrasp_min_transit_z_m, 0.0) * 1000.0,
+        )
+        max_high_z = max(self.args.regrasp_max_transit_z_m, 0.0) * 1000.0
+        if max_high_z > 0.0:
+            desired_high_z = min(desired_high_z, max_high_z)
+        high_target[2] = max(final_target[2], desired_high_z)
+        print(
+            "[Azas] "
+            f"measured cup placement high entry: dispenser={dispenser_id} "
+            f"target_posx=[{high_target[0]:.1f}, {high_target[1]:.1f}, {high_target[2]:.1f}, "
+            f"{high_target[3]:.1f}, {high_target[4]:.1f}, {high_target[5]:.1f}]"
+        )
+        self.move_posx_joint_fallback(
+            high_target,
+            label=f"measured DISP{dispenser_id} high entry before cup place",
+            velocity=self.args.move_prehold_velocity,
+            acceleration=self.args.move_prehold_acceleration,
+        )
+        self.move_posx(
+            final_target,
+            label=f"final measured DISP{dispenser_id} cup-place descent",
+            velocity=self.args.move_velocity,
+            acceleration=self.args.move_acceleration,
+            timeout_sec=self.args.move_timeout_sec,
+        )
+
+    def move_measured_cup_regrasp_with_rear_entry(
+        self,
+        joints_deg: list[float],
+        *,
+        dispenser_id: str,
+        final_regrasp: bool = False,
+    ) -> None:
+        final_target = self.measured_cup_place_posx_with_release_offset(
+            joints_deg,
+            label=f"return to measured DISP{dispenser_id}_PLACE cup re-grasp joints",
+        )
+        if final_regrasp:
+            dx_mm = self.args.final_regrasp_extra_x_offset_m * 1000.0
+            dy_mm = self.args.final_regrasp_extra_y_offset_m * 1000.0
+            dz_mm = self.args.final_regrasp_extra_z_offset_m * 1000.0
+            if abs(dx_mm) > 1e-6 or abs(dy_mm) > 1e-6 or abs(dz_mm) > 1e-6:
+                final_target = list(final_target)
+                final_target[0] += dx_mm
+                final_target[1] += dy_mm
+                final_target[2] += dz_mm
+                print(
+                    "[Azas] "
+                    f"final cup re-grasp tighter target before holder: dispenser={dispenser_id} "
+                    f"dx={dx_mm:.1f}mm dy={dy_mm:.1f}mm dz={dz_mm:.1f}mm "
+                    f"target_posx=[{final_target[0]:.1f}, {final_target[1]:.1f}, {final_target[2]:.1f}, "
+                    f"{final_target[3]:.1f}, {final_target[4]:.1f}, {final_target[5]:.1f}]"
+                )
+        rear_target = list(final_target)
+        rear_target[0] += self.args.regrasp_rear_entry_offset_x_m * 1000.0
+        rear_target[1] += self.args.regrasp_rear_entry_offset_y_m * 1000.0
+        high_rear_target = list(rear_target)
+        desired_high_z = max(
+            final_target[2] + max(self.args.regrasp_approach_offset_z_m, 0.0) * 1000.0,
+            max(self.args.regrasp_min_transit_z_m, 0.0) * 1000.0,
+        )
+        max_high_z = max(self.args.regrasp_max_transit_z_m, 0.0) * 1000.0
+        if max_high_z > 0.0:
+            desired_high_z = min(desired_high_z, max_high_z)
+        high_rear_target[2] = max(rear_target[2], desired_high_z)
+        if (
+            abs(self.args.regrasp_rear_entry_offset_x_m) > 1e-6
+            or abs(self.args.regrasp_rear_entry_offset_y_m) > 1e-6
+        ):
+            print(
+                "[Azas] "
+                f"measured cup re-grasp high rear entry: dispenser={dispenser_id} "
+                f"target_posx=[{high_rear_target[0]:.1f}, {high_rear_target[1]:.1f}, "
+                f"{high_rear_target[2]:.1f}, {high_rear_target[3]:.1f}, "
+                f"{high_rear_target[4]:.1f}, {high_rear_target[5]:.1f}]"
+            )
+            self.move_posx_joint_fallback(
+                high_rear_target,
+                label=f"measured DISP{dispenser_id} high rear entry before cup re-grasp",
+                velocity=self.args.regrasp_approach_velocity,
+                acceleration=self.args.regrasp_approach_acceleration,
+            )
+            print(
+                "[Azas] "
+                f"measured cup re-grasp lowered rear entry: dispenser={dispenser_id} "
+                f"dx={self.args.regrasp_rear_entry_offset_x_m * 1000.0:.1f}mm "
+                f"dy={self.args.regrasp_rear_entry_offset_y_m * 1000.0:.1f}mm "
+                f"target_posx=[{rear_target[0]:.1f}, {rear_target[1]:.1f}, {rear_target[2]:.1f}, "
+                f"{rear_target[3]:.1f}, {rear_target[4]:.1f}, {rear_target[5]:.1f}]"
+            )
+            self.move_posx_joint_fallback(
+                rear_target,
+                label=f"measured DISP{dispenser_id} lowered rear entry before cup re-grasp",
+                velocity=self.args.pick_approach_velocity,
+                acceleration=self.args.pick_approach_acceleration,
+            )
+        self.move_posx(
+            final_target,
+            label=f"final measured DISP{dispenser_id} re-grasp forward approach to cup",
+            velocity=self.args.pick_approach_velocity,
+            acceleration=self.args.pick_approach_acceleration,
+            timeout_sec=self.args.pick_timeout_sec,
+        )
 
     def move_front_hold_joint_fallback(self, posx_mm_deg: list[float], *, label: str) -> None:
         joints_deg = self.ikin_posj(posx_mm_deg, label=f"{label} IK joint fallback")
@@ -727,6 +1043,54 @@ def move_front_hold_joint_fallback(self, posx_mm_deg: list[float], *, label: str
         )
         self.wait_for_target(posx_mm_deg, label=f"{label} IK MoveJoint fallback posx")
 
+    def validate_cartesian_target_z(self, pos_mm_deg: list[float], *, label: str) -> None:
+        min_allowed_mm = max(self.args.min_allowed_tcp_z_m, 0.0) * 1000.0
+        if pos_mm_deg[2] < min_allowed_mm - 1e-6:
+            raise RuntimeError(
+                f"unsafe cartesian target for {label}: "
+                f"target_z={pos_mm_deg[2] / 1000.0:.3f}m < min_allowed_tcp_z={min_allowed_mm / 1000.0:.3f}m; "
+                "no robot command sent"
+            )
+
+    def ensure_start_safe_pose(self) -> None:
+        """Read the live TCP pose and lift straight up before the first XY waypoint."""
+        try:
+            pose = self.current_posx(timeout_sec=self.args.wait_service_sec)
+        except RuntimeError as exc:
+            raise RuntimeError(
+                f"start TCP pose read failed; aborting before any motion: {exc}"
+            ) from exc
+        current_z_m = pose[2] / 1000.0
+        min_allowed_z_m = max(self.args.min_allowed_tcp_z_m, 0.0)
+        start_lift_z_m = max(self.args.start_safe_lift_z_m, min_allowed_z_m, 0.0)
+        print(
+            "[Azas] start TCP pose: "
+            f"posx=[{pose[0]:.1f}, {pose[1]:.1f}, {pose[2]:.1f}, "
+            f"{pose[3]:.1f}, {pose[4]:.1f}, {pose[5]:.1f}] "
+            f"current_z={current_z_m:.3f}m start_safe_lift_z={start_lift_z_m:.3f}m "
+            f"min_allowed_tcp_z={min_allowed_z_m:.3f}m "
+            f"force_start_safe_lift={self.args.force_start_safe_lift}"
+        )
+        if current_z_m < min_allowed_z_m:
+            print(
+                f"[WARN] live TCP Z {current_z_m:.3f}m is below min_allowed_tcp_z "
+                f"{min_allowed_z_m:.3f}m; XY motion stays blocked until the Z-only "
+                "start safe lift completes"
+            )
+        if not self.args.force_start_safe_lift and current_z_m >= start_lift_z_m:
+            print(
+                "[Azas] start safe lift skipped: live TCP already at or above "
+                f"start_safe_lift_z={start_lift_z_m:.3f}m and force_start_safe_lift=false"
+            )
+            return
+        self.safe_lift_current(
+            label="START_SAFE_LIFT Z-only lift from live TCP pose before first waypoint",
+            min_z_m=start_lift_z_m,
+            velocity=self.args.move_prehold_velocity,
+            acceleration=self.args.move_prehold_acceleration,
+            timeout_sec=self.args.move_timeout_sec,
+        )
+
     def safe_lift_current(
         self,
         *,
@@ -746,6 +1110,11 @@ def safe_lift_current(
             )
             return
         target = [pose[0], pose[1], target_z_mm, pose[3], pose[4], pose[5]]
+        safe_lift_tolerance_mm = (
+            self.args.safe_lift_target_tolerance_mm
+            if verify_tolerance_mm is None
+            else verify_tolerance_mm
+        )
         try:
             self.move_posx(
                 target,
@@ -753,11 +1122,7 @@ def safe_lift_current(
                 velocity=velocity,
                 acceleration=acceleration,
                 timeout_sec=timeout_sec,
-                verify_tolerance_mm=(
-                    self.args.safe_lift_target_tolerance_mm
-                    if verify_tolerance_mm is None
-                    else verify_tolerance_mm
-                ),
+                verify_tolerance_mm=safe_lift_tolerance_mm,
             )
         except RuntimeError as exc:
             if not self.args.safe_lift_joint_fallback:
@@ -771,6 +1136,7 @@ def safe_lift_current(
                 label=label,
                 velocity=self.args.safe_lift_joint_fallback_velocity,
                 acceleration=self.args.safe_lift_joint_fallback_acceleration,
+                verify_tolerance_mm=safe_lift_tolerance_mm,
             )
 
     def move_posx(
@@ -783,6 +1149,7 @@ def move_posx(
         timeout_sec: float,
         verify_tolerance_mm: float | None = None,
     ) -> None:
+        self.validate_cartesian_target_z(pos, label=label)
         print(
             f"[Azas] {label}: posx=[{pos[0]:.1f}, {pos[1]:.1f}, {pos[2]:.1f}, "
             f"{pos[3]:.1f}, {pos[4]:.1f}, {pos[5]:.1f}]"
@@ -806,7 +1173,7 @@ def move_posx(
     def move_generated_press_pre(self, pos: list[float], *, label: str) -> None:
         if self.args.press_generated_pre_use_joint:
             print(
-                f"[Azas] {label}: using IK MoveJoint for generated PRESS_PRE approach; "
+                f"[Azas] {label}: using IK MoveJoint for generated press entry approach; "
                 "CONTACT/PRESS stroke remains Z-only MoveLine"
             )
             self.move_posx_joint_fallback(
@@ -829,7 +1196,7 @@ def move_generated_press_pre(self, pos: list[float], *, label: str) -> None:
                 raise
             print(
                 f"[WARN] MoveLine/verification failed for {label}: {exc}; "
-                "retrying the same generated PRESS_PRE with IK MoveJoint fallback"
+                "retrying the same generated press entry target with IK MoveJoint fallback"
             )
             self.move_posx_joint_fallback(
                 pos,
@@ -847,6 +1214,7 @@ def move_posx_no_verify(
         acceleration: float,
         timeout_sec: float,
     ) -> None:
+        self.validate_cartesian_target_z(pos, label=label)
         print(
             f"[Azas] {label}: posx=[{pos[0]:.1f}, {pos[1]:.1f}, {pos[2]:.1f}, "
             f"{pos[3]:.1f}, {pos[4]:.1f}, {pos[5]:.1f}]"
@@ -975,7 +1343,13 @@ def normalize_joints_near_current(self, joints_deg: list[float], *, label: str)
         )
         return list(joints_deg)
 
-    def validate_ik_fallback_joints(self, joints_deg: list[float], *, label: str) -> None:
+    def validate_ik_fallback_joints(
+        self,
+        joints_deg: list[float],
+        *,
+        label: str,
+        max_joint_delta_deg: float | None = None,
+    ) -> None:
         max_abs = max(float(self.args.ik_fallback_max_abs_joint_deg), 0.0)
         if max_abs > 0.0:
             for index, value in enumerate(joints_deg, start=1):
@@ -984,7 +1358,8 @@ def validate_ik_fallback_joints(self, joints_deg: list[float], *, label: str) ->
                         f"IK fallback rejected for {label}: joint_{index}={value:.1f}deg "
                         f"exceeds limit {max_abs:.1f}deg"
                     )
-        max_delta = max(float(self.args.ik_fallback_max_joint_delta_deg), 0.0)
+        delta_limit = self.args.ik_fallback_max_joint_delta_deg if max_joint_delta_deg is None else max_joint_delta_deg
+        max_delta = max(float(delta_limit), 0.0)
         if max_delta <= 0.0:
             return
         current = self.current_posj(timeout_sec=5.0)
@@ -1121,33 +1496,336 @@ def gripper_command(self, command: str, *, width_m: float, force_n: float, label
             print(f"[Azas] {label}: waiting {settle_sec:.2f}s for physical RG2 motion to settle")
             time.sleep(settle_sec)
 
-    def move_and_release(self, dispenser_id: str) -> None:
-        cup_pre_joints = load_cup_pre_place_joints_deg(dispenser_id)
-        cup_place_joints = load_cup_place_joints_deg(dispenser_id)
-        if cup_pre_joints is not None and cup_place_joints is not None:
+    def validate_cup_holder_target(self, posx_mm_deg: list[float], *, label: str) -> None:
+        self.validate_cartesian_target_z(posx_mm_deg, label=label)
+        x_m = posx_mm_deg[0] / 1000.0
+        y_m = posx_mm_deg[1] / 1000.0
+        z_m = posx_mm_deg[2] / 1000.0
+        if not (self.args.cup_holder_x_min_m <= x_m <= self.args.cup_holder_x_max_m):
+            raise RuntimeError(
+                f"cup-holder target {label} rejected: x={x_m:.3f}m outside "
+                f"[{self.args.cup_holder_x_min_m:.3f}, {self.args.cup_holder_x_max_m:.3f}]"
+            )
+        if not (self.args.cup_holder_y_min_m <= y_m <= self.args.cup_holder_y_max_m):
+            raise RuntimeError(
+                f"cup-holder target {label} rejected: y={y_m:.3f}m outside "
+                f"[{self.args.cup_holder_y_min_m:.3f}, {self.args.cup_holder_y_max_m:.3f}]"
+            )
+        if not (self.args.cup_holder_z_min_m <= z_m <= self.args.cup_holder_z_max_m):
+            raise RuntimeError(
+                f"cup-holder target {label} rejected: z={z_m:.3f}m outside "
+                f"[{self.args.cup_holder_z_min_m:.3f}, {self.args.cup_holder_z_max_m:.3f}]"
+            )
+
+    def place_cup_in_holder(self) -> None:
+        pre_place = load_cup_holder_target_posx("pre_place")
+        place_final = load_cup_holder_target_posx("place_final")
+        retreat = load_cup_holder_target_posx("retreat")
+        place_final[1] += self.args.cup_holder_place_final_y_offset_m * 1000.0
+        place_final[2] += self.args.cup_holder_place_final_z_offset_m * 1000.0
+        for label, posx in (
+            ("CUP_HOLDER_PRE_PLACE", pre_place),
+            ("CUP_HOLDER_PLACE_FINAL", place_final),
+            ("CUP_HOLDER_RETREAT", retreat),
+        ):
+            self.validate_cup_holder_target(posx, label=label)
             print(
-                f"[Azas] cup placement: dispenser={dispenser_id} using measured "
-                "DISP_PRE -> DISP_PLACE joint pair; not front_hold_poses"
+                f"[Azas] {label}: posx=[{posx[0]:.1f}, {posx[1]:.1f}, {posx[2]:.1f}, "
+                f"{posx[3]:.1f}, {posx[4]:.1f}, {posx[5]:.1f}]"
+            )
+        print(
+            "[Azas] cup holder place path: "
+            "CUP_HOLDER_PRE_PLACE -> CUP_HOLDER_PLACE_FINAL -> RG2_OPEN -> CUP_HOLDER_RETREAT"
+        )
+        self.move_posx(
+            pre_place,
+            label="CUP_HOLDER_PRE_PLACE measured side-grip approach",
+            velocity=self.args.cup_holder_approach_velocity,
+            acceleration=self.args.cup_holder_approach_acceleration,
+            timeout_sec=self.args.cup_holder_timeout_sec,
+            verify_tolerance_mm=self.args.cup_holder_target_tolerance_mm,
+        )
+        self.move_posx(
+            place_final,
+            label="CUP_HOLDER_PLACE_FINAL measured side-grip place",
+            velocity=self.args.cup_holder_place_velocity,
+            acceleration=self.args.cup_holder_place_acceleration,
+            timeout_sec=self.args.cup_holder_timeout_sec,
+            verify_tolerance_mm=self.args.cup_holder_target_tolerance_mm,
+        )
+        self.gripper_command(
+            "open",
+            width_m=self.args.gripper_open_width_m,
+            force_n=self.args.gripper_open_force_n,
+            label="RG2 full-open at cup holder",
+        )
+        self.move_posx(
+            retreat,
+            label="CUP_HOLDER_RETREAT measured side-grip retreat",
+            velocity=self.args.cup_holder_retreat_velocity,
+            acceleration=self.args.cup_holder_retreat_acceleration,
+            timeout_sec=self.args.cup_holder_timeout_sec,
+            verify_tolerance_mm=self.args.cup_holder_target_tolerance_mm,
+        )
+
+    def _log_release_pose(self, name: str, pos: list[float], *, min_required_z_mm: float) -> None:
+        z_ok = pos[2] >= min_required_z_mm - 1e-6
+        print(
+            f"[Azas] release pose {name}: "
+            f"posx=[{pos[0]:.1f}, {pos[1]:.1f}, {pos[2]:.1f}, {pos[3]:.1f}, {pos[4]:.1f}, {pos[5]:.1f}] "
+            f"z={pos[2] / 1000.0:.3f}m min_required_z={min_required_z_mm / 1000.0:.3f}m z_ok={z_ok}"
+        )
+        if not z_ok:
+            raise RuntimeError(
+                f"release pose {name} failed z validation: "
+                f"z={pos[2] / 1000.0:.3f}m < min_required_z={min_required_z_mm / 1000.0:.3f}m; "
+                "no release command sent"
             )
-            cup_pre_joints = self.normalize_joints_near_current(
-                cup_pre_joints,
-                label=f"move to measured DISP{dispenser_id}_PRE cup-place joints",
+
+    def release_final_posx(self, dispenser_id: str) -> list[float]:
+        """Release final pose (unchanged from the legacy release target)."""
+        cup_place_joints = load_cup_place_joints_deg(dispenser_id)
+        if cup_place_joints is not None:
+            print(f"[Azas] DISP_PLACE={format_joints_deg(cup_place_joints)}")
+            return self.measured_cup_place_posx_with_release_offset(
+                cup_place_joints,
+                label=f"safe release measured DISP{dispenser_id}_PLACE",
             )
-            self.movej(
-                cup_pre_joints,
-                label=f"move to measured DISP{dispenser_id}_PRE cup-place joints",
+        position, quaternion, raw_zyz = load_front_hold_pose(self.args.config, dispenser_id)
+        link6_position = [
+            position[0] + self.args.move_release_offset_x_m,
+            position[1] + self.args.move_release_offset_y_m,
+            position[2] + self.args.move_release_offset_z_m,
+        ]
+        move_position, move_rotation = self.compensate_current_tcp(link6_position, quaternion)
+        move_zyz = matrix_to_doosan_zyz_deg(move_rotation)
+        print(
+            f"[Azas] safe release final from front_hold fallback: dispenser={dispenser_id} "
+            f"link6_target_m=[{link6_position[0]:.4f}, {link6_position[1]:.4f}, {link6_position[2]:.4f}] "
+            f"raw_zyz_deg=[{raw_zyz[0]:.2f}, {raw_zyz[1]:.2f}, {raw_zyz[2]:.2f}]"
+        )
+        return [move_position[0] * 1000.0, move_position[1] * 1000.0, move_position[2] * 1000.0, *move_zyz]
+
+    def _release_transit_move(self, pos: list[float], *, label: str) -> None:
+        try:
+            self.move_posx(
+                pos,
+                label=label,
                 velocity=self.args.move_prehold_velocity,
                 acceleration=self.args.move_prehold_acceleration,
+                timeout_sec=self.args.move_timeout_sec,
+                verify_tolerance_mm=self.args.safe_lift_target_tolerance_mm,
             )
-            cup_place_joints = self.normalize_joints_near_current(
-                cup_place_joints,
-                label=f"move to measured DISP{dispenser_id}_PLACE cup-place joints",
+        except RuntimeError as exc:
+            if not self.args.safe_lift_joint_fallback:
+                raise
+            print(
+                f"[WARN] MoveLine failed for {label}: {exc}; "
+                "retrying the same target with IK MoveJoint fallback"
             )
-            self.movej(
+            self.move_posx_joint_fallback(
+                pos,
+                label=label,
+                velocity=self.args.safe_lift_joint_fallback_velocity,
+                acceleration=self.args.safe_lift_joint_fallback_acceleration,
+                verify_tolerance_mm=self.args.safe_lift_target_tolerance_mm,
+            )
+
+    def safe_release_cup(self, dispenser_id: str) -> None:
+        """Posture-independent cup release.
+
+        Converges from any joint state / TCP position: Z-only lift from the live
+        pose, transit at a safe height, then a vertical-only descent onto the
+        unchanged release final pose. Never moves directly from the current pose
+        to the release final.
+        """
+        print(
+            f"[Azas] safe cup release: dispenser={dispenser_id} "
+            f"skip_release_pre={self.args.skip_release_pre} "
+            f"use_release_staging={self.args.use_release_staging}"
+        )
+        try:
+            current = self.current_posx(timeout_sec=self.args.wait_service_sec)
+        except RuntimeError as exc:
+            raise RuntimeError(
+                f"release start TCP pose read failed; no release command sent: {exc}"
+            ) from exc
+        print(
+            "[Azas] release current TCP pose: "
+            f"posx=[{current[0]:.1f}, {current[1]:.1f}, {current[2]:.1f}, "
+            f"{current[3]:.1f}, {current[4]:.1f}, {current[5]:.1f}]"
+        )
+        min_allowed_mm = max(self.args.min_allowed_tcp_z_m, 0.0) * 1000.0
+        min_transit_mm = max(self.args.release_min_transit_z_m, 0.0) * 1000.0
+
+        final_posx = self.release_final_posx(dispenser_id)
+        above_posx = list(final_posx)
+        above_posx[2] = final_posx[2] + max(self.args.release_approach_lift_m, 0.0) * 1000.0
+        above_high_posx = list(above_posx)
+        above_high_posx[2] = max(above_posx[2], min_transit_mm)
+        staging_posx: list[float] | None = None
+        if self.args.use_release_staging:
+            staging_posx = list(above_high_posx)
+            if self.args.release_staging_x_m is not None:
+                staging_posx[0] = self.args.release_staging_x_m * 1000.0
+            if self.args.release_staging_y_m is not None:
+                staging_posx[1] = self.args.release_staging_y_m * 1000.0
+            if self.args.release_staging_z_m is not None:
+                staging_posx[2] = self.args.release_staging_z_m * 1000.0
+        start_lift_posx = list(current)
+        start_lift_posx[2] = max(
+            current[2] + max(self.args.release_start_safe_lift_m, 0.0) * 1000.0,
+            min_transit_mm,
+        )
+        post_release_posx = list(final_posx)
+        post_release_posx[2] = final_posx[2] + max(self.args.post_release_safe_lift_m, 0.0) * 1000.0
+
+        # Validate every pose before sending any robot command. XY-transit poses
+        # must stay at or above the release transit height; the vertical descent
+        # chain (above -> final) and the post-release lift only need the global
+        # TCP Z floor.
+        self._log_release_pose("release_start_safe_lift", start_lift_posx, min_required_z_mm=min_transit_mm)
+        if staging_posx is not None:
+            self._log_release_pose("release_staging", staging_posx, min_required_z_mm=min_transit_mm)
+        else:
+            print("[Azas] release staging pose disabled (--no-use-release-staging)")
+        self._log_release_pose("release_above_high_entry", above_high_posx, min_required_z_mm=min_transit_mm)
+        self._log_release_pose("release_above", above_posx, min_required_z_mm=min_allowed_mm)
+        self._log_release_pose("release_final", final_posx, min_required_z_mm=min_allowed_mm)
+        self._log_release_pose("post_release_lift", post_release_posx, min_required_z_mm=min_allowed_mm)
+        if above_posx[2] < final_posx[2] - 1e-6:
+            raise RuntimeError(
+                "release_above pose ended up below release_final; check --release-approach-lift-m; "
+                "no release command sent"
+            )
+
+        self._release_transit_move(
+            start_lift_posx,
+            label="release start vertical safe lift (Z-only from live pose)",
+        )
+        if staging_posx is not None and any(
+            abs(staging_posx[index] - above_high_posx[index]) > 1.0 for index in range(3)
+        ):
+            self._release_transit_move(staging_posx, label="release staging pose")
+        self._release_transit_move(
+            above_high_posx,
+            label="release high entry directly above release final",
+        )
+        if above_high_posx[2] - above_posx[2] > 1.0:
+            self.move_posx(
+                above_posx,
+                label="vertical descent to release_above",
+                velocity=self.args.move_velocity,
+                acceleration=self.args.move_acceleration,
+                timeout_sec=self.args.move_timeout_sec,
+            )
+
+        # Final descent is allowed only as a vertical drop from release_above:
+        # the live pose must already match release_above in X/Y/orientation.
+        live = self.current_posx(timeout_sec=self.args.wait_service_sec)
+        xy_tolerance_mm = max(self.args.target_tolerance_mm, 20.0)
+        orientation_tolerance_deg = 5.0
+        xy_error_mm = max(abs(live[0] - above_posx[0]), abs(live[1] - above_posx[1]))
+        orientation_error_deg = max(
+            abs(angular_delta_deg(above_posx[index], live[index])) for index in (3, 4, 5)
+        )
+        if xy_error_mm > xy_tolerance_mm or orientation_error_deg > orientation_tolerance_deg:
+            raise RuntimeError(
+                "release final descent blocked: live pose is not vertically above release final "
+                f"(xy_error={xy_error_mm:.1f}mm tol={xy_tolerance_mm:.1f}mm, "
+                f"orientation_error={orientation_error_deg:.2f}deg tol={orientation_tolerance_deg:.2f}deg); "
+                "no descent command sent"
+            )
+        self.move_posx(
+            final_posx,
+            label="vertical descent to release_final",
+            velocity=self.args.move_velocity,
+            acceleration=self.args.move_acceleration,
+            timeout_sec=self.args.move_timeout_sec,
+        )
+        self.gripper_command(
+            "open",
+            width_m=self.args.gripper_open_width_m,
+            force_n=self.args.gripper_open_force_n,
+            label="RG2 full-open release",
+        )
+        print("[Azas] RG2 full-open release complete; continuing only after open settle wait")
+        self.move_posx(
+            post_release_posx,
+            label="post-release vertical lift above released cup",
+            velocity=self.args.pick_lift_velocity,
+            acceleration=self.args.pick_lift_acceleration,
+            timeout_sec=self.args.move_timeout_sec,
+        )
+
+    def move_and_release(self, dispenser_id: str) -> None:
+        if self.args.skip_release_pre:
+            self.safe_release_cup(dispenser_id)
+            return
+        cup_common_pre_joints = load_cup_common_pre_joints_deg(dispenser_id) if self.args.use_cup_common_pre else None
+        cup_place_joints = load_cup_place_joints_deg(dispenser_id)
+        if cup_place_joints is not None:
+            if cup_common_pre_joints is not None:
+                print(f"[Azas] CUP_COMMON_PRE={format_joints_deg(cup_common_pre_joints)}")
+            print(f"[Azas] DISP_PLACE={format_joints_deg(cup_place_joints)}")
+            final_target = self.measured_cup_place_posx_with_release_offset(
                 cup_place_joints,
-                label=f"move to measured DISP{dispenser_id}_PLACE cup-place joints",
+                label=f"DISP{dispenser_id}_PLACE source measured DISP_PLACE",
+            )
+            if cup_common_pre_joints is not None:
+                print(
+                    f"[Azas] cup placement: dispenser={dispenser_id} using "
+                    "CUP_COMMON_PRE -> DISP_PLACE; saved cup_pre_place_joints_deg ignored"
+                )
+                self.movej(
+                    cup_common_pre_joints,
+                    label="CUP_COMMON_PRE common cup-place pre joints",
+                    velocity=self.args.move_prehold_velocity,
+                    acceleration=self.args.move_prehold_acceleration,
+                )
+            else:
+                print(
+                    f"[Azas] cup placement: dispenser={dispenser_id} using measured "
+                    "DISP_PLACE with generated DISP_PRE from X offset; saved cup_pre_place_joints_deg ignored"
+                )
+                pre_target = list(final_target)
+                pre_target[0] += self.args.cup_pre_from_place_x_offset_m * 1000.0
+                pre_target[2] += self.args.cup_pre_from_place_z_offset_m * 1000.0
+                print(
+                    "[Azas] generated cup pre: "
+                    f"dispenser={dispenser_id} "
+                    f"pre_x_offset={self.args.cup_pre_from_place_x_offset_m * 1000.0:.1f}mm "
+                    f"pre_z_offset={self.args.cup_pre_from_place_z_offset_m * 1000.0:.1f}mm "
+                    f"target_posx=[{pre_target[0]:.1f}, {pre_target[1]:.1f}, {pre_target[2]:.1f}, "
+                    f"{pre_target[3]:.1f}, {pre_target[4]:.1f}, {pre_target[5]:.1f}]"
+                )
+                pre_label = f"generated DISP{dispenser_id}_PRE from DISP_PLACE X/Z offset"
+                if self.args.generated_cup_pre_use_joint_fallback:
+                    print(
+                        f"[Azas] {pre_label}: using IK MoveJoint fallback because "
+                        "generated_cup_pre_use_joint_fallback=true"
+                    )
+                    self.move_posx_joint_fallback(
+                        pre_target,
+                        label=pre_label,
+                        velocity=self.args.move_prehold_velocity,
+                        acceleration=self.args.move_prehold_acceleration,
+                        max_joint_delta_deg=self.args.generated_cup_pre_max_joint_delta_deg,
+                    )
+                else:
+                    self.move_posx(
+                        pre_target,
+                        label=pre_label,
+                        velocity=self.args.move_prehold_velocity,
+                        acceleration=self.args.move_prehold_acceleration,
+                        timeout_sec=self.args.move_timeout_sec,
+                    )
+            self.move_posx(
+                final_target,
+                label=f"DISP_PLACE measured DISP{dispenser_id} cup release",
                 velocity=self.args.move_velocity,
                 acceleration=self.args.move_acceleration,
+                timeout_sec=self.args.move_timeout_sec,
             )
             self.gripper_command(
                 "open",
@@ -1207,16 +1885,38 @@ def move_and_release(self, dispenser_id: str) -> None:
         )
         print("[Azas] RG2 full-open release complete; continuing only after open settle wait")
 
-    def regrasp_and_lift(self, dispenser_id: str) -> None:
-        self.safe_lift_current(
-            label="safe vertical lift after press before re-grasp transit",
-            min_z_m=self.args.post_press_safe_lift_z_m,
-            velocity=self.args.regrasp_approach_velocity,
-            acceleration=self.args.regrasp_approach_acceleration,
-            timeout_sec=self.args.move_timeout_sec,
-            verify_tolerance_mm=self.args.post_press_safe_lift_target_tolerance_mm,
+    def regrasp_and_lift(self, dispenser_id: str, *, final_regrasp: bool = False) -> None:
+        grasp_width_m = (
+            self.args.final_regrasp_grasp_width_m
+            if final_regrasp
+            else self.args.gripper_grasp_width_m
         )
-        if abs(self.args.regrasp_retreat_y_m) > 1e-6 or abs(self.args.regrasp_retreat_x_m) > 1e-6:
+        grasp_force_n = self.args.final_regrasp_force_n if final_regrasp else self.args.gripper_force_n
+        grasp_label = "RG2 tight final side-grasp before cup holder" if final_regrasp else "RG2 soft side-grasp"
+        if self.args.regrasp_reset_before_cup:
+            print(
+                "[Azas] re-grasp transit: moving through HOME joint waypoint before returning to cup; "
+                "skipping post-press Cartesian high-Z lift"
+            )
+            self.movej(
+                list(self.args.regrasp_reset_joints_deg),
+                label="move to re-grasp HOME joints before cup return",
+                velocity=self.args.regrasp_reset_joint_velocity,
+                acceleration=self.args.regrasp_reset_joint_acceleration,
+            )
+        else:
+            self.safe_lift_current(
+                label="safe vertical lift after press before re-grasp transit",
+                min_z_m=self.args.post_press_safe_lift_z_m,
+                velocity=self.args.regrasp_approach_velocity,
+                acceleration=self.args.regrasp_approach_acceleration,
+                timeout_sec=self.args.move_timeout_sec,
+                verify_tolerance_mm=self.args.post_press_safe_lift_target_tolerance_mm,
+            )
+        if (
+            not self.args.regrasp_reset_before_cup
+            and (abs(self.args.regrasp_retreat_y_m) > 1e-6 or abs(self.args.regrasp_retreat_x_m) > 1e-6)
+        ):
             pose = self.current_posx()
             retreat = [
                 pose[0] + self.args.regrasp_retreat_x_m * 1000.0,
@@ -1234,12 +1934,11 @@ def regrasp_and_lift(self, dispenser_id: str) -> None:
                 timeout_sec=self.args.move_timeout_sec,
                 verify_tolerance_mm=self.args.safe_lift_target_tolerance_mm,
             )
-        cup_pre_joints = load_cup_pre_place_joints_deg(dispenser_id)
         cup_place_joints = load_cup_place_joints_deg(dispenser_id)
-        if cup_pre_joints is not None and cup_place_joints is not None:
+        if cup_place_joints is not None:
             print(
                 f"[Azas] cup re-grasp: dispenser={dispenser_id} using measured "
-                "DISP_PRE -> DISP_PLACE joint pair; not front_hold_poses"
+                "DISP_PLACE with generated high rear-entry; not front_hold_poses"
             )
             self.gripper_command(
                 "open",
@@ -1247,31 +1946,16 @@ def regrasp_and_lift(self, dispenser_id: str) -> None:
                 force_n=self.args.gripper_open_force_n,
                 label="RG2 open at safe robot-side retreat before measured cup re-grasp",
             )
-            cup_pre_joints = self.normalize_joints_near_current(
-                cup_pre_joints,
-                label=f"return to measured DISP{dispenser_id}_PRE cup re-grasp joints",
-            )
-            self.movej(
-                cup_pre_joints,
-                label=f"return to measured DISP{dispenser_id}_PRE cup re-grasp joints",
-                velocity=self.args.regrasp_approach_velocity,
-                acceleration=self.args.regrasp_approach_acceleration,
-            )
-            cup_place_joints = self.normalize_joints_near_current(
+            self.move_measured_cup_regrasp_with_rear_entry(
                 cup_place_joints,
-                label=f"return to measured DISP{dispenser_id}_PLACE cup re-grasp joints",
-            )
-            self.movej(
-                cup_place_joints,
-                label=f"return to measured DISP{dispenser_id}_PLACE cup re-grasp joints",
-                velocity=self.args.pick_approach_velocity,
-                acceleration=self.args.pick_approach_acceleration,
+                dispenser_id=dispenser_id,
+                final_regrasp=final_regrasp,
             )
             self.gripper_command(
                 "set_width",
-                width_m=self.args.gripper_grasp_width_m,
-                force_n=self.args.gripper_force_n,
-                label="RG2 soft side-grasp",
+                width_m=grasp_width_m,
+                force_n=grasp_force_n,
+                label=grasp_label,
             )
             pose = self.current_posx()
             target = [pose[0], pose[1], pose[2] + max(self.args.pick_lift_m, 0.0) * 1000.0, pose[3], pose[4], pose[5]]
@@ -1293,7 +1977,20 @@ def regrasp_and_lift(self, dispenser_id: str) -> None:
             return
 
         front_hold_position, _, _ = load_front_hold_pose(self.args.config, dispenser_id)
-        released_hold_z_m = front_hold_position[2] + self.args.move_release_offset_z_m
+        final_offset_x_m = self.args.move_release_offset_x_m
+        final_offset_y_m = self.args.move_release_offset_y_m
+        final_offset_z_m = self.args.move_release_offset_z_m
+        if final_regrasp:
+            final_offset_x_m += self.args.final_regrasp_extra_x_offset_m
+            final_offset_y_m += self.args.final_regrasp_extra_y_offset_m
+            final_offset_z_m += self.args.final_regrasp_extra_z_offset_m
+            print(
+                "[Azas] "
+                f"final front-hold re-grasp tighter offset before holder: dispenser={dispenser_id} "
+                f"offset_x={final_offset_x_m:.3f}m offset_y={final_offset_y_m:.3f}m "
+                f"offset_z={final_offset_z_m:.3f}m"
+            )
+        released_hold_z_m = front_hold_position[2] + final_offset_z_m
         desired_approach_z_m = max(
             released_hold_z_m + max(self.args.regrasp_approach_offset_z_m, 0.0),
             max(self.args.regrasp_min_transit_z_m, 0.0),
@@ -1305,8 +2002,8 @@ def regrasp_and_lift(self, dispenser_id: str) -> None:
                 f"{desired_approach_z_m:.3f}m to {capped_approach_z_m:.3f}m"
             )
         approach_offset_z_m = max(capped_approach_z_m - front_hold_position[2], 0.0)
-        rear_offset_x_m = self.args.move_release_offset_x_m + self.args.regrasp_rear_entry_offset_x_m
-        rear_offset_y_m = self.args.move_release_offset_y_m + self.args.regrasp_rear_entry_offset_y_m
+        rear_offset_x_m = final_offset_x_m + self.args.regrasp_rear_entry_offset_x_m
+        rear_offset_y_m = final_offset_y_m + self.args.regrasp_rear_entry_offset_y_m
         self.move_front_hold(
             dispenser_id,
             label="re-grasp high transit above rear entry",
@@ -1328,24 +2025,24 @@ def regrasp_and_lift(self, dispenser_id: str) -> None:
             label="re-grasp lowered rear entry before forward approach",
             offset_x_m=rear_offset_x_m,
             offset_y_m=rear_offset_y_m,
-            offset_z_m=self.args.move_release_offset_z_m,
+            offset_z_m=final_offset_z_m,
             velocity=self.args.pick_approach_velocity,
             acceleration=self.args.pick_approach_acceleration,
         )
         self.move_front_hold(
             dispenser_id,
             label="final re-grasp forward approach to cup",
-            offset_x_m=self.args.move_release_offset_x_m,
-            offset_y_m=self.args.move_release_offset_y_m,
-            offset_z_m=self.args.move_release_offset_z_m,
+            offset_x_m=final_offset_x_m,
+            offset_y_m=final_offset_y_m,
+            offset_z_m=final_offset_z_m,
             velocity=self.args.pick_approach_velocity,
             acceleration=self.args.pick_approach_acceleration,
         )
         self.gripper_command(
             "set_width",
-            width_m=self.args.gripper_grasp_width_m,
-            force_n=self.args.gripper_force_n,
-            label="RG2 soft side-grasp",
+            width_m=grasp_width_m,
+            force_n=grasp_force_n,
+            label=grasp_label,
         )
         pose = self.current_posx()
         target = [pose[0], pose[1], pose[2] + max(self.args.pick_lift_m, 0.0) * 1000.0, pose[3], pose[4], pose[5]]
@@ -1365,16 +2062,284 @@ def regrasp_and_lift(self, dispenser_id: str) -> None:
         self.wait_motion_done("post-grasp lift", timeout_sec=self.args.pick_timeout_sec)
         self.wait_for_target(target, label="post-grasp lift")
 
-    def press_dispenser(self, dispenser_id: str, press_count: int) -> None:
+    def press_dispenser(self, dispenser_id: str, press_count: int) -> None:
+        current_pose = self.current_posx()
+        press_drop_m = max(self.args.press_depth_m, 0.0) + max(self.args.press_extra_depth_m, 0.0)
+        contact_joints = None if self.args.force_cartesian_press else load_press_ready_joints_deg(dispenser_id)
+        skip_measured_press_pre = bool(self.args.skip_measured_press_pre)
+        pre_joints = (
+            None
+            if self.args.force_cartesian_press or skip_measured_press_pre
+            else load_press_pre_joints_deg(dispenser_id)
+        )
+        press_common_pre_joints = None if self.args.force_cartesian_press else load_press_common_pre_joints_deg(dispenser_id)
+
+        if contact_joints is not None and (skip_measured_press_pre or pre_joints is not None):
+            print(f"[Azas] skip_measured_press_pre={str(skip_measured_press_pre).lower()}")
+            if not skip_measured_press_pre:
+                print(f"[Azas] PRESS_PRE={format_joints_deg(pre_joints)}")
+            if skip_measured_press_pre and self.args.press_reset_before_press and press_common_pre_joints is not None:
+                print(f"[Azas] PRESS_COMMON_PRE={format_joints_deg(press_common_pre_joints)}")
+            print(f"[Azas] PRESS_CONTACT={format_joints_deg(contact_joints)}")
+            common_pre_path = ""
+            if skip_measured_press_pre and self.args.press_reset_before_press:
+                common_pre_path = "PRESS_COMMON_PRE -> " if press_common_pre_joints is not None else "PRESS_RESET_HOME -> "
+            if skip_measured_press_pre:
+                print(
+                    "[Azas] measured press path: "
+                    f"SAFE_LIFT -> {common_pre_path}CONTACT_ENTRY_LIFT -> PRESS_CONTACT -> "
+                    f"(PRESS_Z_OVERDRIVE -> PRESS_CONTACT) x{max(int(press_count), 1)} -> "
+                    "POST_PRESS_SAFE_LIFT -> REGRASP"
+                )
+            else:
+                print(
+                    "[Azas] measured press path: "
+                    "SAFE_LIFT -> PRESS_PRE -> CONTACT_ENTRY_LIFT -> PRESS_CONTACT -> "
+                    "PRESS_Z_OVERDRIVE -> PRESS_CONTACT -> PRESS_PRE -> REGRASP"
+                )
+            if abs(self.args.press_pre_lift_retreat_x_m) > 1e-6 or abs(self.args.press_pre_lift_retreat_y_m) > 1e-6:
+                retreat = [
+                    current_pose[0] + self.args.press_pre_lift_retreat_x_m * 1000.0,
+                    current_pose[1] + self.args.press_pre_lift_retreat_y_m * 1000.0,
+                    current_pose[2],
+                    current_pose[3],
+                    current_pose[4],
+                    current_pose[5],
+                ]
+                self.move_posx(
+                    retreat,
+                    label="SAFE_LIFT pre-step robot-side X retreat away from dispenser before press",
+                    velocity=self.args.press_travel_velocity,
+                    acceleration=self.args.press_travel_acceleration,
+                    timeout_sec=self.args.press_timeout_sec,
+                )
+                current_pose = self.current_posx(timeout_sec=self.args.wait_service_sec)
+            transit_z = max(
+                current_pose[2] + max(self.args.press_transit_height_m, 0.0) * 1000.0,
+                max(self.args.press_min_transit_z_m, 0.0) * 1000.0,
+            )
+            safe_lift = [
+                current_pose[0],
+                current_pose[1],
+                transit_z,
+                current_pose[3],
+                current_pose[4],
+                current_pose[5],
+            ]
+            self.move_posx(
+                safe_lift,
+                label=(
+                    "SAFE_LIFT away from released cup before CONTACT_ENTRY_LIFT"
+                    if skip_measured_press_pre
+                    else "SAFE_LIFT away from released cup before measured PRESS_PRE"
+                ),
+                velocity=self.args.press_travel_velocity,
+                acceleration=self.args.press_travel_acceleration,
+                timeout_sec=self.args.press_timeout_sec,
+                verify_tolerance_mm=self.args.safe_lift_target_tolerance_mm,
+            )
+            self.gripper_command(
+                "set_width",
+                width_m=self.args.press_gripper_close_width_m,
+                force_n=self.args.press_gripper_force_n,
+                label="RG2 close empty gripper for dispenser press",
+            )
+            if skip_measured_press_pre and self.args.press_reset_before_press:
+                if press_common_pre_joints is not None:
+                    reset_joints = list(press_common_pre_joints)
+                    reset_label = "PRESS_COMMON_PRE common contact pre joints before CONTACT_ENTRY_LIFT"
+                else:
+                    reset_joints = list(self.args.press_reset_joints_deg)
+                    reset_label = "move to press HOME joints before CONTACT_ENTRY_LIFT"
+                self.movej(
+                    reset_joints,
+                    label=reset_label,
+                    velocity=self.args.press_reset_joint_velocity,
+                    acceleration=self.args.press_reset_joint_acceleration,
+                )
+
+            if not skip_measured_press_pre:
+                pre_joints = self.normalize_joints_near_current(
+                    list(pre_joints),
+                    label="PRESS_PRE measured joints",
+                )
+                self.movej(
+                    pre_joints,
+                    label="PRESS_PRE measured press pre-contact joints",
+                    velocity=self.args.press_pre_joint_velocity,
+                    acceleration=self.args.press_pre_joint_acceleration,
+                )
+            contact_joints = list(contact_joints)
+            raw_contact_joints = list(contact_joints)
+            if self.args.press_lock_contact_joint_indexes:
+                if skip_measured_press_pre:
+                    print(
+                        "[WARN] press contact joint lock ignored because "
+                        "skip_measured_press_pre=true and measured pre-contact joints are not commanded"
+                    )
+                else:
+                    contact_joints = lock_joints_to_reference(
+                        contact_joints,
+                        pre_joints,
+                        self.args.press_lock_contact_joint_indexes,
+                    )
+                    if contact_joints != raw_contact_joints:
+                        print(
+                            "[Azas] press contact joint lock: raw=["
+                            + ", ".join(f"{value:.2f}" for value in raw_contact_joints)
+                            + "] command=["
+                            + ", ".join(f"{value:.2f}" for value in contact_joints)
+                            + "] locked_joints="
+                            + ",".join(str(index + 1) for index in sorted(self.args.press_lock_contact_joint_indexes))
+                        )
+            contact_joints = self.normalize_joints_near_current(
+                contact_joints,
+                label="PRESS_CONTACT measured joints",
+            )
+            # Generated entry-lift pose directly above the measured contact: every
+            # contact approach must pass through it so the press always enters from
+            # straight above instead of from an arbitrary PRESS_PRE direction.
+            entry_lift_m = max(self.args.press_contact_entry_lift_m, 0.0)
+            contact_fk_posx = self.fkin_posx(
+                contact_joints,
+                label=f"measured PRESS_CONTACT FK for entry lift dispenser {dispenser_id}",
+            )
+            contact_entry_posx = list(contact_fk_posx[:6])
+            contact_entry_posx[2] += entry_lift_m * 1000.0
+            self.validate_cartesian_target_z(
+                contact_entry_posx,
+                label=f"generated PRESS_CONTACT entry lift dispenser {dispenser_id}",
+            )
+            print(
+                "[Azas] integrated press: "
+                f"dispenser={dispenser_id} count={press_count} "
+                f"PRESS_CONTACT={format_joints_deg(contact_joints)} "
+                f"contact_entry_z={contact_entry_posx[2] / 1000.0:.3f}m "
+                f"(entry_lift={entry_lift_m * 1000.0:.1f}mm) "
+                f"z_overdrive_m={press_drop_m:.3f}"
+                + (
+                    " source=PRESS_CONTACT_FK; measured pre-contact joints skipped; "
+                    f"press_contact_use_joint_move={str(self.args.press_contact_use_joint_move).lower()}"
+                    if skip_measured_press_pre
+                    else f" PRESS_PRE={format_joints_deg(pre_joints)}"
+                )
+            )
+            if skip_measured_press_pre:
+                self.move_generated_press_pre(
+                    contact_entry_posx,
+                    label="CONTACT_ENTRY_LIFT above measured PRESS_CONTACT",
+                )
+                if self.args.press_contact_use_joint_move:
+                    self.movej(
+                        contact_joints,
+                        label="PRESS_CONTACT measured contact joints",
+                        velocity=self.args.press_contact_joint_velocity,
+                        acceleration=self.args.press_contact_joint_acceleration,
+                    )
+                else:
+                    self.move_posx(
+                        list(contact_fk_posx[:6]),
+                        label="Z-only descend to measured PRESS_CONTACT FK",
+                        velocity=self.args.press_line_velocity,
+                        acceleration=self.args.press_line_acceleration,
+                        timeout_sec=self.args.press_timeout_sec,
+                        verify_tolerance_mm=max(self.args.target_tolerance_mm, 25.0),
+                    )
+                contact_posx = self.current_posx(timeout_sec=self.args.wait_service_sec)
+                for press_index in range(1, max(int(press_count), 1) + 1):
+                    suffix = f" {press_index}/{press_count}" if press_count > 1 else ""
+                    if press_drop_m > 0.0:
+                        extra_press_posx = list(contact_posx)
+                        extra_press_posx[2] -= press_drop_m * 1000.0
+                        self.move_posx(
+                            extra_press_posx,
+                            label=f"PRESS_Z_OVERDRIVE from stable measured contact{suffix}",
+                            velocity=self.args.press_line_velocity,
+                            acceleration=self.args.press_line_acceleration,
+                            timeout_sec=self.args.press_timeout_sec,
+                            verify_tolerance_mm=max(self.args.target_tolerance_mm, 25.0),
+                        )
+                        if self.args.press_hold_seconds > 0.0:
+                            time.sleep(self.args.press_hold_seconds)
+                        self.move_posx(
+                            contact_posx,
+                            label=f"return to stable PRESS_CONTACT after Z overdrive{suffix}",
+                            velocity=self.args.press_line_velocity,
+                            acceleration=self.args.press_line_acceleration,
+                            timeout_sec=self.args.press_timeout_sec,
+                            verify_tolerance_mm=max(self.args.target_tolerance_mm, 25.0),
+                        )
+                    elif self.args.press_hold_seconds > 0.0:
+                        time.sleep(self.args.press_hold_seconds)
+                self.move_posx(
+                    contact_entry_posx,
+                    label="POST_PRESS_SAFE_LIFT above measured PRESS_CONTACT",
+                    velocity=self.args.press_line_velocity,
+                    acceleration=self.args.press_line_acceleration,
+                    timeout_sec=self.args.press_timeout_sec,
+                    verify_tolerance_mm=max(self.args.target_tolerance_mm, 25.0),
+                )
+                if self.args.press_post_retreat_wait_seconds > 0.0:
+                    time.sleep(self.args.press_post_retreat_wait_seconds)
+                return
+
+            for press_index in range(1, max(int(press_count), 1) + 1):
+                suffix = f" {press_index}/{press_count}" if press_count > 1 else ""
+                self.move_generated_press_pre(
+                    contact_entry_posx,
+                    label=f"CONTACT_ENTRY_LIFT above measured PRESS_CONTACT{suffix}",
+                )
+                self.movej(
+                    contact_joints,
+                    label=f"PRESS_CONTACT measured contact joints{suffix}",
+                    velocity=self.args.press_contact_joint_velocity,
+                    acceleration=self.args.press_contact_joint_acceleration,
+                )
+                if press_drop_m > 0.0:
+                    contact_posx = self.current_posx(timeout_sec=self.args.wait_service_sec)
+                    extra_press_posx = list(contact_posx)
+                    extra_press_posx[2] -= press_drop_m * 1000.0
+                    self.move_posx(
+                        extra_press_posx,
+                        label=f"PRESS_Z_OVERDRIVE from measured contact{suffix}",
+                        velocity=self.args.press_line_velocity,
+                        acceleration=self.args.press_line_acceleration,
+                        timeout_sec=self.args.press_timeout_sec,
+                        verify_tolerance_mm=max(self.args.target_tolerance_mm, 25.0),
+                    )
+                    if self.args.press_hold_seconds > 0.0:
+                        time.sleep(self.args.press_hold_seconds)
+                    self.move_posx(
+                        contact_posx,
+                        label=f"return to PRESS_CONTACT after Z overdrive{suffix}",
+                        velocity=self.args.press_line_velocity,
+                        acceleration=self.args.press_line_acceleration,
+                        timeout_sec=self.args.press_timeout_sec,
+                        verify_tolerance_mm=max(self.args.target_tolerance_mm, 25.0),
+                    )
+                elif self.args.press_hold_seconds > 0.0:
+                    time.sleep(self.args.press_hold_seconds)
+                if skip_measured_press_pre:
+                    self.move_posx(
+                        contact_entry_posx,
+                        label=f"POST_PRESS_SAFE_LIFT above measured PRESS_CONTACT{suffix}",
+                        velocity=self.args.press_line_velocity,
+                        acceleration=self.args.press_line_acceleration,
+                        timeout_sec=self.args.press_timeout_sec,
+                        verify_tolerance_mm=max(self.args.target_tolerance_mm, 25.0),
+                    )
+                else:
+                    self.movej(
+                        pre_joints,
+                        label=f"return to PRESS_PRE measured press pre-contact joints{suffix}",
+                        velocity=self.args.press_pre_joint_velocity,
+                        acceleration=self.args.press_pre_joint_acceleration,
+                    )
+            if self.args.press_post_retreat_wait_seconds > 0.0:
+                time.sleep(self.args.press_post_retreat_wait_seconds)
+            return
+
         press_xyz_m, press_rpy_deg = load_press_pose(dispenser_id)
-        current_pose = self.current_posx()
-        press_drop_m = max(self.args.press_depth_m, 0.0) + max(self.args.press_extra_depth_m, 0.0)
-        contact_joints = None if self.args.force_cartesian_press else load_press_ready_joints_deg(dispenser_id)
-        pre_joints = (
-            load_press_pre_joints_deg(dispenser_id)
-            if (not self.args.force_cartesian_press and self.args.press_use_recorded_pre_joints)
-            else None
-        )
         joint_space_press = contact_joints is not None
         if contact_joints is None:
             x_mm = press_xyz_m[0] * 1000.0
@@ -1405,9 +2370,9 @@ def press_dispenser(self, dispenser_id: str, press_count: int) -> None:
             )
             x_mm, y_mm, contact_z, rx, ry, rz = contact_fk_posx[:6]
         if joint_space_press:
-            # PRESS_CONTACT is the only taught press pose.  PRE and the actual
-            # pump stroke are generated by changing only Z from the FK contact
-            # pose so XY/orientation cannot drift to a neighboring dispenser.
+            # Fallback for older calibration where PRESS_CONTACT is the only
+            # taught press pose. PRE and the pump stroke are generated by
+            # changing only Z from the FK contact pose.
             generated_pre_lift_m = max(self.args.press_contact_entry_lift_m, 0.0)
             pre_z = contact_z + generated_pre_lift_m * 1000.0
             transit_z = max(
@@ -1476,7 +2441,7 @@ def press_dispenser(self, dispenser_id: str, press_count: int) -> None:
             reset_joints = list(self.args.press_reset_joints_deg)
             self.movej(
                 reset_joints,
-                label="move to press HOME joints before generated PRESS_PRE",
+                label="move to press HOME joints before fallback generated PRESS_PRE",
                 velocity=self.args.press_reset_joint_velocity,
                 acceleration=self.args.press_reset_joint_acceleration,
             )
@@ -1538,166 +2503,48 @@ def press_dispenser(self, dispenser_id: str, press_count: int) -> None:
                 time.sleep(self.args.press_post_retreat_wait_seconds)
             return
 
-        if joint_space_press and pre_joints is not None:
-            print(
-                "[Azas] joint-space press: measured PRESS_PRE -> PRESS_CONTACT joint pair; "
-                "not using live TCP XY for Z-only press because TCP setup can be unavailable"
-            )
-            pre_joints = self.normalize_joints_near_current(
-                pre_joints,
-                label="move to measured press pre-contact joints",
-            )
-            self.movej(
-                pre_joints,
-                label="move to measured press pre-contact joints",
-                velocity=self.args.press_pre_joint_velocity,
-                acceleration=self.args.press_pre_joint_acceleration,
-            )
-            raw_contact_joints = list(contact_joints)
-            if self.args.press_lock_contact_joint_indexes:
-                contact_joints = lock_joints_to_reference(
-                    contact_joints,
-                    pre_joints,
-                    self.args.press_lock_contact_joint_indexes,
+        steps: list[tuple[list[float], str, float, float]] = []
+        if joint_space_press:
+            if self.args.press_move_configured_prepose_before_joint:
+                self.move_posx(
+                    [x_mm, y_mm, pre_z, rx, ry, rz],
+                    label="fallback high pre pose before measured PRESS_CONTACT",
+                    velocity=self.args.press_travel_velocity,
+                    acceleration=self.args.press_travel_acceleration,
+                    timeout_sec=self.args.press_timeout_sec,
+                )
+            else:
+                print("[Azas] joint-space press fallback: no PRESS_PRE joints; using generated CONTACT+Z entry")
+            if self.args.press_contact_entry_lift_m > 0.0:
+                entry_z = contact_z + max(self.args.press_contact_entry_lift_m, 0.0) * 1000.0
+                self.move_posx(
+                    [x_mm, y_mm, entry_z, rx, ry, rz],
+                    label="fallback safe high waypoint above measured PRESS_CONTACT",
+                    velocity=self.args.press_travel_velocity,
+                    acceleration=self.args.press_travel_acceleration,
+                    timeout_sec=self.args.press_timeout_sec,
                 )
-                if contact_joints != raw_contact_joints:
-                    print(
-                        "[Azas] press contact joint lock: raw=["
-                        + ", ".join(f"{value:.2f}" for value in raw_contact_joints)
-                        + "] command=["
-                        + ", ".join(f"{value:.2f}" for value in contact_joints)
-                        + "] locked_joints="
-                        + ",".join(str(index + 1) for index in sorted(self.args.press_lock_contact_joint_indexes))
-                    )
             contact_joints = self.normalize_joints_near_current(
                 contact_joints,
-                label="move to measured press contact joints",
+                label="fallback PRESS_CONTACT measured joints",
+            )
+            self.movej(
+                contact_joints,
+                label="fallback PRESS_CONTACT measured contact joints",
+                velocity=self.args.press_contact_joint_velocity,
+                acceleration=self.args.press_contact_joint_acceleration,
             )
+            contact_posx = self.current_posx(timeout_sec=self.args.wait_service_sec)
+            x_mm, y_mm, contact_z, rx, ry, rz = contact_posx
+            pre_z = contact_z
+            pressed_z = contact_z - press_drop_m * 1000.0
             print(
-                "[Azas] integrated press: "
+                "[Azas] integrated press fallback: "
                 f"dispenser={dispenser_id} count={press_count} "
-                f"press_pre_joints=[{', '.join(f'{value:.1f}' for value in pre_joints)}] "
-                f"press_contact_joints=[{', '.join(f'{value:.1f}' for value in contact_joints)}] "
-                f"z_overdrive_m={press_drop_m:.3f} "
-                f"(press_depth_m={max(self.args.press_depth_m, 0.0):.3f}, "
-                f"extra={max(self.args.press_extra_depth_m, 0.0):.3f})"
+                f"contact=({x_mm:.1f}, {y_mm:.1f}, {contact_z:.1f}) "
+                f"pressed_z={pressed_z:.1f} z_descent={contact_z - pressed_z:.1f}mm "
+                "source=live TCP after CONTACT-only fallback"
             )
-            for press_index in range(1, max(int(press_count), 1) + 1):
-                suffix = f" {press_index}/{press_count}" if press_count > 1 else ""
-                self.movej(
-                    contact_joints,
-                    label=f"press dispenser measured contact joints{suffix}",
-                    velocity=self.args.press_contact_joint_velocity,
-                    acceleration=self.args.press_contact_joint_acceleration,
-                )
-                if press_drop_m > 0.0:
-                    contact_posx = self.current_posx(timeout_sec=self.args.wait_service_sec)
-                    extra_press_posx = list(contact_posx)
-                    extra_press_posx[2] -= press_drop_m * 1000.0
-                    self.move_posx(
-                        extra_press_posx,
-                        label=f"press extra Z overdrive{suffix}",
-                        velocity=self.args.press_line_velocity,
-                        acceleration=self.args.press_line_acceleration,
-                        timeout_sec=self.args.press_timeout_sec,
-                        verify_tolerance_mm=max(self.args.target_tolerance_mm, 25.0),
-                    )
-                    if self.args.press_hold_seconds > 0.0:
-                        time.sleep(self.args.press_hold_seconds)
-                    self.move_posx(
-                        contact_posx,
-                        label=f"return from extra Z overdrive{suffix}",
-                        velocity=self.args.press_line_velocity,
-                        acceleration=self.args.press_line_acceleration,
-                        timeout_sec=self.args.press_timeout_sec,
-                        verify_tolerance_mm=max(self.args.target_tolerance_mm, 25.0),
-                    )
-                elif self.args.press_hold_seconds > 0.0:
-                    time.sleep(self.args.press_hold_seconds)
-                self.movej(
-                    pre_joints,
-                    label=f"retreat to measured press pre-contact joints{suffix}",
-                    velocity=self.args.press_pre_joint_velocity,
-                    acceleration=self.args.press_pre_joint_acceleration,
-                )
-            if self.args.press_post_retreat_wait_seconds > 0.0:
-                time.sleep(self.args.press_post_retreat_wait_seconds)
-            return
-
-        steps: list[tuple[list[float], str, float, float]] = []
-        if joint_space_press:
-            if pre_joints is not None:
-                if self.args.press_move_configured_prepose_before_joint:
-                    print(
-                        "[Azas] joint-space press: ignoring configured Cartesian pre pose; "
-                        "PRESS_PRE joints are the safe approach for Z-only pressing"
-                    )
-                else:
-                    print("[Azas] joint-space press: PRESS_PRE joints -> Z-only press; no contact-joint MoveJoint")
-                pre_joints = self.normalize_joints_near_current(
-                    pre_joints,
-                    label="move to measured press pre-contact joints",
-                )
-                self.movej(
-                    pre_joints,
-                    label="move to measured press pre-contact joints",
-                    velocity=self.args.press_pre_joint_velocity,
-                    acceleration=self.args.press_pre_joint_acceleration,
-                )
-                pre_posx = self.current_posx(timeout_sec=self.args.wait_service_sec)
-                x_mm, y_mm, pre_z, rx, ry, rz = pre_posx
-                contact_z = pre_z
-                pressed_z = pre_z - press_drop_m * 1000.0
-                print(
-                    "[Azas] integrated press: "
-                    f"dispenser={dispenser_id} count={press_count} "
-                    f"z_only_start=({x_mm:.1f}, {y_mm:.1f}, {pre_z:.1f}) "
-                    f"pressed_z={pressed_z:.1f} z_descent={pre_z - pressed_z:.1f}mm "
-                    "source=live TCP at measured PRESS_PRE"
-                )
-            else:
-                if self.args.press_move_configured_prepose_before_joint:
-                    self.move_posx(
-                        [x_mm, y_mm, pre_z, rx, ry, rz],
-                        label="high pre pose before measured press joint",
-                        velocity=self.args.press_travel_velocity,
-                        acceleration=self.args.press_travel_acceleration,
-                        timeout_sec=self.args.press_timeout_sec,
-                    )
-                else:
-                    print(
-                        "[Azas] joint-space press: no PRESS_PRE joints; falling back to contact-joint MoveJoint"
-                    )
-                if self.args.press_contact_entry_lift_m > 0.0:
-                    entry_z = contact_z + max(self.args.press_contact_entry_lift_m, 0.0) * 1000.0
-                    self.move_posx(
-                        [x_mm, y_mm, entry_z, rx, ry, rz],
-                        label="safe high waypoint above measured press contact",
-                        velocity=self.args.press_travel_velocity,
-                        acceleration=self.args.press_travel_acceleration,
-                        timeout_sec=self.args.press_timeout_sec,
-                    )
-                contact_joints = self.normalize_joints_near_current(
-                    contact_joints,
-                    label="move to measured press contact joints fallback",
-                )
-                self.movej(
-                    contact_joints,
-                    label="move to measured press contact joints fallback",
-                    velocity=self.args.press_contact_joint_velocity,
-                    acceleration=self.args.press_contact_joint_acceleration,
-                )
-                contact_posx = self.current_posx(timeout_sec=self.args.wait_service_sec)
-                x_mm, y_mm, contact_z, rx, ry, rz = contact_posx
-                pre_z = contact_z
-                pressed_z = contact_z - press_drop_m * 1000.0
-                print(
-                    "[Azas] integrated press fallback: "
-                    f"dispenser={dispenser_id} count={press_count} "
-                    f"contact=({x_mm:.1f}, {y_mm:.1f}, {contact_z:.1f}) "
-                    f"pressed_z={pressed_z:.1f} z_descent={contact_z - pressed_z:.1f}mm "
-                    "source=live TCP after contact-joint fallback"
-                )
         else:
             steps.extend(
                 [
@@ -1928,7 +2775,7 @@ def press_cmd(args: argparse.Namespace, dispenser_id: str, press_count: int) ->
         "-p pre_home_retreat_dy_mm:=0.0 "
         "-p pre_home_retreat_min_z_mm:=520.0 -p pre_home_retreat_lift_first:=true "
         "-p pre_home_retreat_min_current_x_mm:=450.0 "
-        "-p pre_home_retreat_velocity:=20.0 "
+        "-p pre_home_retreat_velocity:=80.0 "
         "-p pre_home_retreat_acceleration:=25.0 "
         "-p joint1_clearance_before_home:=false "
         "-p joint1_clearance_return_home:=false "
@@ -1947,11 +2794,11 @@ def press_cmd(args: argparse.Namespace, dispenser_id: str, press_count: int) ->
         "-p service_wait_timeout_sec:=10.0 "
         "-p pose_position_tolerance_mm:=8.0 "
         "-p pose_orientation_tolerance_deg:=6.0 "
-        "-p line_velocity:=20.0 "
+        "-p line_velocity:=80.0 "
         "-p line_acceleration:=30.0 "
-        "-p travel_line_velocity:=45.0 "
+        "-p travel_line_velocity:=80.0 "
         "-p travel_line_acceleration:=70.0 "
-        "-p joint_velocity:=40.0 "
+        "-p joint_velocity:=80.0 "
         "-p joint_acceleration:=50.0"
     )
 
@@ -2030,9 +2877,54 @@ def parse_args() -> argparse.Namespace:
             "the measured gripper TCP stays active for follow-up recipe motions."
         ),
     )
-    parser.add_argument("--move-velocity", type=float, default=18.0)
+    parser.add_argument("--move-velocity", type=float, default=80.0)
     parser.add_argument("--move-acceleration", type=float, default=25.0)
     parser.add_argument("--move-prehold-offset-x-m", type=float, default=-0.030)
+    parser.add_argument(
+        "--cup-pre-from-place-x-offset-m",
+        type=float,
+        default=-0.090,
+        help=(
+            "Generate DISP_PRE from the latest measured cup_place pose by changing only X. "
+            "Default -0.090m."
+        ),
+    )
+    parser.add_argument(
+        "--cup-pre-from-place-z-offset-m",
+        type=float,
+        default=0.030,
+        help=(
+            "Generate DISP_PRE from the latest measured cup_place pose by changing only Z. "
+            "Default +0.030m."
+        ),
+    )
+    parser.add_argument(
+        "--use-cup-common-pre",
+        action=argparse.BooleanOptionalAction,
+        default=False,
+        help=(
+            "Use calibration.yaml cup_common_pre_joints_deg before DISP_PLACE. "
+            "Default false: generate cup pre from cup_place with X/Z offsets."
+        ),
+    )
+    parser.add_argument(
+        "--generated-cup-pre-use-joint-fallback",
+        action=argparse.BooleanOptionalAction,
+        default=False,
+        help=(
+            "Use IK MoveJoint for generated DISP_PRE. Default false: generated DISP_PRE "
+            "uses Cartesian MoveLine so X/Z-offset cup pre does not jump to a different wrist/joint branch."
+        ),
+    )
+    parser.add_argument(
+        "--generated-cup-pre-max-joint-delta-deg",
+        type=float,
+        default=190.0,
+        help=(
+            "Joint delta guard used only when --generated-cup-pre-use-joint-fallback is enabled. "
+            "Default 190deg preserves the old fallback limit without affecting the default Cartesian path."
+        ),
+    )
     parser.add_argument(
         "--move-prehold-offset-y-m",
         type=float,
@@ -2070,18 +2962,18 @@ def parse_args() -> argparse.Namespace:
         default=0.0,
         help="Final cup release Z offset from measured front_hold. Default 0 uses the taught cup-place height exactly.",
     )
-    parser.add_argument("--move-prehold-velocity", type=float, default=16.0)
+    parser.add_argument("--move-prehold-velocity", type=float, default=80.0)
     parser.add_argument("--move-prehold-acceleration", type=float, default=22.0)
     parser.add_argument("--move-timeout-sec", type=float, default=180.0)
-    parser.add_argument("--pick-approach-velocity", type=float, default=10.0)
+    parser.add_argument("--pick-approach-velocity", type=float, default=80.0)
     parser.add_argument("--pick-approach-acceleration", type=float, default=14.0)
     parser.add_argument("--pick-pregrasp-offset-x-m", type=float, default=0.0)
     parser.add_argument("--pick-pregrasp-offset-y-m", type=float, default=0.0)
     parser.add_argument("--pick-pregrasp-offset-z-m", type=float, default=0.0)
-    parser.add_argument("--pick-pregrasp-staging-velocity", type=float, default=12.0)
+    parser.add_argument("--pick-pregrasp-staging-velocity", type=float, default=80.0)
     parser.add_argument("--pick-pregrasp-staging-acceleration", type=float, default=16.0)
     parser.add_argument("--pick-lift-m", type=float, default=0.100)
-    parser.add_argument("--pick-lift-velocity", type=float, default=18.0)
+    parser.add_argument("--pick-lift-velocity", type=float, default=80.0)
     parser.add_argument("--pick-lift-acceleration", type=float, default=25.0)
     parser.add_argument("--pick-timeout-sec", type=float, default=120.0)
     parser.add_argument(
@@ -2099,6 +2991,97 @@ def parse_args() -> argparse.Namespace:
             "The following re-grasp high transit still uses --regrasp-min-transit-z-m."
         ),
     )
+    parser.add_argument(
+        "--start-safe-lift-z-m",
+        type=float,
+        default=0.15,
+        help=(
+            "Minimum absolute TCP Z for the start-of-sequence vertical lift. The sequence "
+            "reads the live TCP pose first and raises only Z to this height before any "
+            "XY waypoint motion."
+        ),
+    )
+    parser.add_argument(
+        "--min-allowed-tcp-z-m",
+        type=float,
+        default=0.02,
+        help=(
+            "Reject any Cartesian target pose whose absolute TCP Z is below this height. "
+            "A failed check prints an error and aborts before any robot command is sent."
+        ),
+    )
+    parser.add_argument(
+        "--force-start-safe-lift",
+        action=argparse.BooleanOptionalAction,
+        default=True,
+        help=(
+            "Always run the start-of-sequence Z-only safe lift regardless of the current "
+            "TCP height. With --no-force-start-safe-lift the lift still runs whenever the "
+            "live TCP Z is below --start-safe-lift-z-m."
+        ),
+    )
+    parser.add_argument(
+        "--skip-release-pre",
+        action=argparse.BooleanOptionalAction,
+        default=False,
+        help=(
+            "Use the posture-independent safe release structure instead of the generated "
+            "DISP_PRE-from-DISP_PLACE release waypoint. Default false: cup pre is generated "
+            "from the latest cup_place pose by X offset."
+        ),
+    )
+    parser.add_argument(
+        "--release-approach-lift-m",
+        type=float,
+        default=0.100,
+        help="Height of the generated release_above pose over the release final pose (same X/Y/orientation).",
+    )
+    parser.add_argument(
+        "--release-start-safe-lift-m",
+        type=float,
+        default=0.120,
+        help="Relative Z-only lift from the live TCP pose at the start of the safe release.",
+    )
+    parser.add_argument(
+        "--release-min-transit-z-m",
+        type=float,
+        default=0.300,
+        help=(
+            "Minimum absolute TCP Z for every XY-transit pose of the safe release "
+            "(start lift, staging, high entry). The vertical descent chain above->final "
+            "is exempt but still checked against --min-allowed-tcp-z-m."
+        ),
+    )
+    parser.add_argument(
+        "--post-release-safe-lift-m",
+        type=float,
+        default=0.100,
+        help="Vertical lift above the release final pose right after the gripper opens.",
+    )
+    parser.add_argument(
+        "--release-staging-x-m",
+        type=float,
+        default=None,
+        help="Optional absolute base-frame X of the release staging pose. Default: release final X.",
+    )
+    parser.add_argument(
+        "--release-staging-y-m",
+        type=float,
+        default=None,
+        help="Optional absolute base-frame Y of the release staging pose. Default: release final Y.",
+    )
+    parser.add_argument(
+        "--release-staging-z-m",
+        type=float,
+        default=None,
+        help="Optional absolute base-frame Z of the release staging pose. Default: release transit height.",
+    )
+    parser.add_argument(
+        "--use-release-staging",
+        action=argparse.BooleanOptionalAction,
+        default=True,
+        help="Route the safe release through the staging pose before the above-final entry.",
+    )
     parser.add_argument(
         "--regrasp-approach-offset-z-m",
         type=float,
@@ -2114,8 +3097,24 @@ def parse_args() -> argparse.Namespace:
         default=0.560,
         help="Maximum absolute TCP/front-hold high approach Z used for post-press re-grasp transit.",
     )
-    parser.add_argument("--regrasp-approach-velocity", type=float, default=14.0)
+    parser.add_argument("--regrasp-approach-velocity", type=float, default=80.0)
     parser.add_argument("--regrasp-approach-acceleration", type=float, default=18.0)
+    parser.add_argument(
+        "--regrasp-reset-before-cup",
+        action=argparse.BooleanOptionalAction,
+        default=True,
+        help=(
+            "After pressing, move through a fixed HOME joint waypoint before returning to the cup. "
+            "Default true because the Cartesian post-press high-Z lift can stall near the dispenser."
+        ),
+    )
+    parser.add_argument(
+        "--regrasp-reset-joints-deg",
+        default="0,0,90,0,90,180",
+        help="HOME joint pose used after dispenser press, before returning to cup re-grasp.",
+    )
+    parser.add_argument("--regrasp-reset-joint-velocity", type=float, default=80.0)
+    parser.add_argument("--regrasp-reset-joint-acceleration", type=float, default=35.0)
     parser.add_argument(
         "--regrasp-retreat-x-m",
         type=float,
@@ -2134,7 +3133,7 @@ def parse_args() -> argparse.Namespace:
     parser.add_argument(
         "--regrasp-rear-entry-offset-x-m",
         type=float,
-        default=-0.080,
+        default=-0.090,
         help=(
             "Extra X offset from final release pose for the lowered rear entry before re-grasp. "
             "Negative X approaches from the robot side instead of sliding sideways along dispenser slots."
@@ -2158,10 +3157,10 @@ def parse_args() -> argparse.Namespace:
     parser.add_argument(
         "--press-depth-m",
         type=float,
-        default=0.040,
+        default=0.070,
         help=(
             "Z-only pump stroke after the measured PRESS_CONTACT joints touch the dispenser. "
-            "Default is 0.040 m (4 cm)."
+            "Default is 0.070 m (7 cm)."
         ),
     )
     parser.add_argument(
@@ -2199,10 +3198,10 @@ def parse_args() -> argparse.Namespace:
         default=0.500,
         help="Minimum absolute TCP Z before moving from cup release toward dispenser press joints.",
     )
-    parser.add_argument("--press-line-velocity", type=float, default=18.0)
-    parser.add_argument("--press-line-acceleration", type=float, default=25.0)
-    parser.add_argument("--press-travel-velocity", type=float, default=45.0)
-    parser.add_argument("--press-travel-acceleration", type=float, default=60.0)
+    parser.add_argument("--press-line-velocity", type=float, default=25.0)
+    parser.add_argument("--press-line-acceleration", type=float, default=10.0)
+    parser.add_argument("--press-travel-velocity", type=float, default=40.0)
+    parser.add_argument("--press-travel-acceleration", type=float, default=20.0)
     parser.add_argument("--press-timeout-sec", type=float, default=120.0)
     parser.add_argument("--press-hold-seconds", type=float, default=0.25)
     parser.add_argument("--press-gripper-close-width-m", type=float, default=0.0)
@@ -2212,28 +3211,49 @@ def parse_args() -> argparse.Namespace:
         action=argparse.BooleanOptionalAction,
         default=True,
         help=(
-            "After cup release, safe lift, and empty-gripper close, move through a fixed HOME joint pose "
-            "before approaching generated PRESS_PRE. Default true to avoid direct cup-place -> press Cartesian transitions."
+            "After cup release, safe lift, and empty-gripper close, move through "
+            "calibration.yaml press_common_pre_joints_deg before CONTACT_ENTRY_LIFT. "
+            "If that key is missing, falls back to --press-reset-joints-deg. "
+            "Default false because the measured common pre/HOME joint waypoint can choose a large wrist branch."
         ),
     )
     parser.add_argument(
         "--press-reset-joints-deg",
         default="0,0,90,0,90,0",
-        help="HOME joint pose used after safe lift and RG2 close, before moving to generated PRESS_PRE.",
+        help="Fallback HOME joint pose used only when press_common_pre_joints_deg is missing.",
     )
-    parser.add_argument("--press-reset-joint-velocity", type=float, default=18.0)
+    parser.add_argument("--press-reset-joint-velocity", type=float, default=80.0)
     parser.add_argument("--press-reset-joint-acceleration", type=float, default=25.0)
-    parser.add_argument("--press-pre-joint-velocity", type=float, default=18.0)
+    parser.add_argument("--press-pre-joint-velocity", type=float, default=80.0)
     parser.add_argument("--press-pre-joint-acceleration", type=float, default=25.0)
-    parser.add_argument("--press-contact-joint-velocity", type=float, default=22.0)
-    parser.add_argument("--press-contact-joint-acceleration", type=float, default=30.0)
+    parser.add_argument("--press-contact-joint-velocity", type=float, default=35.0)
+    parser.add_argument("--press-contact-joint-acceleration", type=float, default=15.0)
+    parser.add_argument(
+        "--press-contact-use-joint-move",
+        action=argparse.BooleanOptionalAction,
+        default=False,
+        help=(
+            "Use measured PRESS_CONTACT movej after CONTACT_ENTRY_LIFT. Default false: "
+            "PRESS_CONTACT joints are used only for FK, then the robot descends Z-only by Cartesian MoveLine."
+        ),
+    )
     parser.add_argument(
         "--press-contact-entry-lift-m",
         type=float,
         default=0.050,
         help=(
-            "Generated Cartesian PRE height above the measured PRESS_CONTACT FK pose. "
-            "PRESS_PRE joints are ignored by default; PRE is CONTACT with Z raised by this amount."
+            "Generated Cartesian CONTACT_ENTRY_LIFT height above measured PRESS_CONTACT FK. "
+            "Default stays in the 50-80mm hardware-safe range."
+        ),
+    )
+    parser.add_argument(
+        "--skip-measured-press-pre",
+        action=argparse.BooleanOptionalAction,
+        default=True,
+        help=(
+            "Default true: ignore calibration.yaml press_pre_joints_deg and approach/retreat "
+            "through PRESS_CONTACT FK with Z raised by --press-contact-entry-lift-m. "
+            "Use --no-skip-measured-press-pre to restore the old measured PRESS_PRE joint path."
         ),
     )
     parser.add_argument(
@@ -2352,7 +3372,7 @@ def parse_args() -> argparse.Namespace:
             "MoveLine enters a singularity or stalls target verification."
         ),
     )
-    parser.add_argument("--front-hold-joint-fallback-velocity", type=float, default=30.0)
+    parser.add_argument("--front-hold-joint-fallback-velocity", type=float, default=80.0)
     parser.add_argument("--front-hold-joint-fallback-acceleration", type=float, default=40.0)
     parser.add_argument(
         "--safe-lift-joint-fallback",
@@ -2363,25 +3383,25 @@ def parse_args() -> argparse.Namespace:
             "retry the same live-TCP-derived high-Z target with IK MoveJoint before failing."
         ),
     )
-    parser.add_argument("--safe-lift-joint-fallback-velocity", type=float, default=30.0)
+    parser.add_argument("--safe-lift-joint-fallback-velocity", type=float, default=80.0)
     parser.add_argument("--safe-lift-joint-fallback-acceleration", type=float, default=40.0)
     parser.add_argument(
         "--press-generated-pre-use-joint",
         action=argparse.BooleanOptionalAction,
-        default=True,
+        default=False,
         help=(
-            "Approach the generated high PRESS_PRE pose with IK MoveJoint by default. "
-            "This avoids long Cartesian orientation interpolation from cup-place posture near the dispenser. "
-            "The actual contact/press stroke remains Z-only MoveLine."
+            "Approach the generated CONTACT_ENTRY_LIFT/PRESS_PRE pose with IK MoveJoint. "
+            "Default false: press entry uses Cartesian MoveLine to avoid large wrist/joint branch changes."
         ),
     )
     parser.add_argument(
         "--press-generated-pre-joint-fallback",
         action=argparse.BooleanOptionalAction,
-        default=True,
+        default=False,
         help=(
             "When MoveLine to generated PRESS_PRE returns complete but target verification stalls, "
-            "retry that high approach pose with IK MoveJoint. The actual contact/press stroke remains Z-only MoveLine."
+            "retry that high approach pose with IK MoveJoint. Default false because press entry should not "
+            "fall back to a large joint branch unless explicitly requested."
         ),
     )
     parser.add_argument("--gripper-service", default="/jarvis/rg2/set_width")
@@ -2390,6 +3410,41 @@ def parse_args() -> argparse.Namespace:
     parser.add_argument("--gripper-grasp-width-m", type=float, default=0.075)
     parser.add_argument("--gripper-force-n", type=float, default=25.0)
     parser.add_argument("--gripper-timeout-sec", type=float, default=12.0)
+    parser.add_argument(
+        "--final-regrasp-extra-x-offset-m",
+        type=float,
+        default=0.020,
+        help=(
+            "Only for the final re-grasp before cup-holder placement: add this X offset "
+            "to the cup re-grasp target. Positive X moves closer toward the dispenser/cup."
+        ),
+    )
+    parser.add_argument("--final-regrasp-extra-y-offset-m", type=float, default=0.0)
+    parser.add_argument("--final-regrasp-extra-z-offset-m", type=float, default=0.0)
+    parser.add_argument("--final-regrasp-grasp-width-m", type=float, default=0.068)
+    parser.add_argument("--final-regrasp-force-n", type=float, default=35.0)
+    parser.add_argument(
+        "--place-cup-holder-after-sequence",
+        action=argparse.BooleanOptionalAction,
+        default=True,
+        help="After the final dispenser re-grasp, place the held cup into calibration.yaml cup_holder.side_grip_place.",
+    )
+    parser.add_argument("--cup-holder-place-final-z-offset-m", type=float, default=-0.030)
+    parser.add_argument("--cup-holder-place-final-y-offset-m", type=float, default=-0.010)
+    parser.add_argument("--cup-holder-approach-velocity", type=float, default=80.0)
+    parser.add_argument("--cup-holder-approach-acceleration", type=float, default=20.0)
+    parser.add_argument("--cup-holder-place-velocity", type=float, default=80.0)
+    parser.add_argument("--cup-holder-place-acceleration", type=float, default=10.0)
+    parser.add_argument("--cup-holder-retreat-velocity", type=float, default=80.0)
+    parser.add_argument("--cup-holder-retreat-acceleration", type=float, default=16.0)
+    parser.add_argument("--cup-holder-timeout-sec", type=float, default=90.0)
+    parser.add_argument("--cup-holder-target-tolerance-mm", type=float, default=12.0)
+    parser.add_argument("--cup-holder-x-min-m", type=float, default=0.35)
+    parser.add_argument("--cup-holder-x-max-m", type=float, default=0.50)
+    parser.add_argument("--cup-holder-y-min-m", type=float, default=0.15)
+    parser.add_argument("--cup-holder-y-max-m", type=float, default=0.30)
+    parser.add_argument("--cup-holder-z-min-m", type=float, default=0.08)
+    parser.add_argument("--cup-holder-z-max-m", type=float, default=0.28)
     parser.add_argument(
         "--gripper-settle-seconds",
         type=float,
@@ -2410,19 +3465,19 @@ def parse_args() -> argparse.Namespace:
     )
     parser.add_argument(
         "--press-lock-contact-joints",
-        default="6",
+        default="",
         help=(
             "Comma-separated joint numbers copied from press_pre_joints_deg into "
-            "press_contact_joints_deg before MoveJoint when --press-use-recorded-pre-joints is enabled. Default 6 prevents wrist spin "
-            "when recorded contact J6 is an equivalent 233deg branch."
+            "press_contact_joints_deg before MoveJoint. Default empty: command measured PRESS_CONTACT exactly."
         ),
     )
     parser.add_argument(
         "--press-use-recorded-pre-joints",
-        action="store_true",
+        action=argparse.BooleanOptionalAction,
+        default=True,
         help=(
-            "Compatibility mode only: use press_pre_joints_deg as a measured joint pose. "
-            "Default false because PRESS_PRE is generated from PRESS_CONTACT by raising Z."
+            "Deprecated compatibility flag accepted for old commands. Ignored by the integrated path: "
+            "use --no-skip-measured-press-pre when the old measured PRESS_PRE joint path is explicitly needed."
         ),
     )
     parser.add_argument(
@@ -2478,6 +3533,11 @@ def parse_args() -> argparse.Namespace:
         expected_count=6,
         label="--press-reset-joints-deg",
     )
+    args.regrasp_reset_joints_deg = parse_float_list(
+        args.regrasp_reset_joints_deg,
+        expected_count=6,
+        label="--regrasp-reset-joints-deg",
+    )
     args.press_lock_contact_joint_indexes = parse_joint_index_set(
         args.press_lock_contact_joints,
         label="--press-lock-contact-joints",
@@ -2518,7 +3578,53 @@ def main() -> int:
         f"[Azas] measured_joint_press_z_overdrive_m={max(args.press_depth_m, 0.0) + max(args.press_extra_depth_m, 0.0):.3f} "
         f"(press_depth_m={args.press_depth_m:.3f}, extra={args.press_extra_depth_m:.3f})"
     )
-    print("[Azas] source=calibration.yaml measured DISP_PRE/DISP_PLACE and PRESS_CONTACT-only Z press")
+    print(f"[Azas] skip_measured_press_pre={str(args.skip_measured_press_pre).lower()}")
+    if args.skip_measured_press_pre:
+        print(
+            "[Azas] source=calibration.yaml generated DISP_PRE from DISP_PLACE X/Z offset, measured DISP_PLACE, "
+            "and PRESS_CONTACT FK teaching; press_pre_joints_deg ignored by default; "
+            "PRESS_COMMON_PRE is used only with --press-reset-before-press"
+        )
+    else:
+        print("[Azas] source=calibration.yaml generated DISP_PRE from DISP_PLACE X/Z offset, measured DISP_PLACE and PRESS_PRE/PRESS_CONTACT joint teaching")
+    release_path = (
+        "SAFE_RELEASE(Z_LIFT -> STAGING/ABOVE -> vertical RELEASE_FINAL -> OPEN -> POST_LIFT)"
+        if args.skip_release_pre
+        else (
+            "CUP_COMMON_PRE -> DISP_PLACE -> RELEASE"
+            if args.use_cup_common_pre
+            else "GENERATED_DISP_PRE(X/Z offset) -> DISP_PLACE -> RELEASE"
+        )
+    )
+    press_common_pre_path = "PRESS_COMMON_PRE -> " if args.press_reset_before_press else ""
+    press_path = (
+        f"SAFE_LIFT -> {press_common_pre_path}CONTACT_ENTRY_LIFT -> PRESS_CONTACT -> PRESS_Z_OVERDRIVE -> "
+        "PRESS_CONTACT -> POST_PRESS_SAFE_LIFT -> REGRASP"
+        if args.skip_measured_press_pre
+        else (
+            "SAFE_LIFT -> PRESS_PRE -> CONTACT_ENTRY_LIFT -> PRESS_CONTACT -> "
+            "PRESS_Z_OVERDRIVE -> PRESS_CONTACT -> PRESS_PRE -> REGRASP"
+        )
+    )
+    print(f"[Azas] default_path=START_SAFE_LIFT -> {release_path} -> {press_path}")
+    print(
+        f"[Azas] start_safety: force_start_safe_lift={args.force_start_safe_lift} "
+        f"start_safe_lift_z_m={max(args.start_safe_lift_z_m, 0.0):.3f} "
+        f"min_allowed_tcp_z_m={max(args.min_allowed_tcp_z_m, 0.0):.3f}"
+    )
+    print(
+        f"[Azas] release_safety: skip_release_pre={args.skip_release_pre} "
+        f"use_release_staging={args.use_release_staging} "
+        f"release_start_safe_lift_m={max(args.release_start_safe_lift_m, 0.0):.3f} "
+        f"release_min_transit_z_m={max(args.release_min_transit_z_m, 0.0):.3f} "
+        f"release_approach_lift_m={max(args.release_approach_lift_m, 0.0):.3f} "
+        f"post_release_safe_lift_m={max(args.post_release_safe_lift_m, 0.0):.3f}"
+    )
+    print(
+        f"[Azas] cup_holder_after_sequence={str(args.place_cup_holder_after_sequence).lower()} "
+        f"place_final_y_offset_m={args.cup_holder_place_final_y_offset_m:.3f} "
+        f"place_final_z_offset_m={args.cup_holder_place_final_z_offset_m:.3f}"
+    )
 
     motion: IntegratedRecipeMotion | None = None
     if args.execute and not args.legacy_subprocess_primitives:
@@ -2531,13 +3637,27 @@ def main() -> int:
             if motion is not None:
                 motion.close()
             return 1
+        try:
+            motion.ensure_start_safe_pose()
+        except RuntimeError as exc:
+            print(f"[FAIL] start safe lift failed; no recipe motion sent: {exc}")
+            motion.close()
+            return 1
     elif args.execute:
         print("[Azas] integrated_motion=false (legacy subprocess primitives requested)")
+        if args.force_start_safe_lift or args.skip_release_pre:
+            print(
+                "[BLOCKED] legacy subprocess primitives cannot run the start safe lift or the "
+                "posture-independent safe release; use integrated motion or pass "
+                "--no-force-start-safe-lift and --no-skip-release-pre explicitly"
+            )
+            return 2
 
     try:
         total_groups = len(grouped_dispenser_ids)
         for index, (dispenser_id, press_count) in enumerate(grouped_dispenser_ids, start=1):
             label_prefix = f"recipe group {index}/{total_groups} dispenser {dispenser_id} x{press_count}"
+            final_regrasp = index == total_groups
             print(f"[Azas] START {label_prefix}: physical_dispenser={dispenser_id}")
             if args.execute:
                 try:
@@ -2609,8 +3729,9 @@ def main() -> int:
                     return rc
             else:
                 try:
-                    print(f"[Azas] {label_prefix}: RE-GRASP physical_dispenser={dispenser_id}")
-                    motion.regrasp_and_lift(dispenser_id)
+                    regrasp_label = "FINAL RE-GRASP" if final_regrasp else "RE-GRASP"
+                    print(f"[Azas] {label_prefix}: {regrasp_label} physical_dispenser={dispenser_id}")
+                    motion.regrasp_and_lift(dispenser_id, final_regrasp=final_regrasp)
                 except RuntimeError as exc:
                     if not args.integrated_regrasp_fallback_subprocess:
                         print(f"[FAIL] {label_prefix}: integrated re-grasp/lift failed: {exc}")
@@ -2641,6 +3762,59 @@ def main() -> int:
                 )
                 if rc != 0:
                     return rc
+        if not args.execute:
+            if args.place_cup_holder_after_sequence:
+                print(
+                    "[PLAN] after final re-grasp: CUP_HOLDER_PRE_PLACE -> "
+                    "CUP_HOLDER_PLACE_FINAL -> RG2_OPEN -> CUP_HOLDER_RETREAT"
+                )
+        elif args.place_cup_holder_after_sequence:
+            if motion is None:
+                rc = run_command(
+                    "place final cup in holder",
+                    [
+                        sys.executable,
+                        str(ROOT / "tools" / "run" / "place_side_grip_cup_in_holder.py"),
+                        "--service-prefix",
+                        args.service_prefix,
+                        "--config",
+                        str(CALIBRATION_CONFIG),
+                        "--motion-backend",
+                        "direct",
+                        "--approach-velocity",
+                        f"{args.cup_holder_approach_velocity:.6f}",
+                        "--approach-acceleration",
+                        f"{args.cup_holder_approach_acceleration:.6f}",
+                        "--place-velocity",
+                        f"{args.cup_holder_place_velocity:.6f}",
+                        "--place-acceleration",
+                        f"{args.cup_holder_place_acceleration:.6f}",
+                        "--retreat-velocity",
+                        f"{args.cup_holder_retreat_velocity:.6f}",
+                        "--retreat-acceleration",
+                        f"{args.cup_holder_retreat_acceleration:.6f}",
+                        "--place-final-z-offset-m",
+                        f"{args.cup_holder_place_final_z_offset_m:.6f}",
+                        "--place-final-y-offset-m",
+                        f"{args.cup_holder_place_final_y_offset_m:.6f}",
+                        "--timeout-sec",
+                        f"{args.cup_holder_timeout_sec:.6f}",
+                        "--target-tolerance-mm",
+                        f"{args.cup_holder_target_tolerance_mm:.6f}",
+                        "--execute",
+                        "--confirm",
+                        "ENABLE_CUP_HOLDER_PLACE",
+                    ],
+                )
+                if rc != 0:
+                    return rc
+            else:
+                try:
+                    print("[Azas] final: PLACE CUP IN HOLDER")
+                    motion.place_cup_in_holder()
+                except RuntimeError as exc:
+                    print(f"[FAIL] final cup-holder place failed: {exc}")
+                    return 1
     finally:
         if motion is not None:
             motion.close()
diff --git a/tools/run/run_rule_based_shake_real.sh b/tools/run/run_rule_based_shake_real.sh
index 299acd6..b47781d 100755
--- a/tools/run/run_rule_based_shake_real.sh
+++ b/tools/run/run_rule_based_shake_real.sh
@@ -288,7 +288,22 @@ else
   echo "[Azas] Cup-holder pick skipped only because SKIP_CUP_HOLDER_PICK=true was set by a wrapper that already completed it."
 fi
 
-exec ros2 launch azas_bringup tumbler_shake_sequence.launch.py \
+# Stale side-grip workspace walls left by earlier pick stages repeatedly fail
+# the shake-ready MoveIt state-validity check (link_2 <-> ..._x_min_wall).
+# workspace_collision_scene_node keeps re-publishing the walls every cycle, so
+# stop it first; a plain scene removal would be overwritten within seconds.
+if pgrep -f "workspace_collision_scene_node" >/dev/null 2>&1; then
+  echo "[Azas] Stopping leftover workspace_collision_scene_node (it re-publishes the side-grip walls)."
+  pkill -f "workspace_collision_scene_node" || true
+  sleep 1.5
+fi
+echo "[Azas] Removing stale side-grip workspace walls from MoveIt scene (best-effort)."
+python3 "${ROOT_DIR}/tools/run/remove_moveit_collision_objects.py" \
+  --ids side_grip_workspace_x_min_wall,side_grip_workspace_x_max_wall,side_grip_workspace_y_min_wall,side_grip_workspace_y_max_wall \
+  || echo "[Azas] workspace wall removal returned non-zero (walls likely absent already); continuing."
+
+SHAKE_RUN_LOG="$(mktemp /tmp/azas_shake_run.XXXXXX.log)"
+ros2 launch azas_bringup tumbler_shake_sequence.launch.py \
   enable_hardware:=true \
   hardware_confirm:=ENABLE_REAL_ROBOT_MOTION \
   allow_service_control_without_moveit:=true \
@@ -353,4 +368,13 @@ exec ros2 launch azas_bringup tumbler_shake_sequence.launch.py \
   joint_target_poll_sec:="${JOINT_TARGET_POLL_SEC}" \
   require_state_validity_for_joint_shake:="${REQUIRE_STATE_VALIDITY_FOR_JOINT_SHAKE}" \
   state_validity_service:="${STATE_VALIDITY_SERVICE}" \
-  planning_group:="${PLANNING_GROUP}"
+  planning_group:="${PLANNING_GROUP}" 2>&1 | tee "${SHAKE_RUN_LOG}"
+
+# ros2 launch exits 0 even when the shake node refused/aborted the motion, so
+# the panel used to report success on a failed shake. Fail closed on the node's
+# own failure markers.
+if grep -q "refusing MoveJoint\|tumbler_shake_sequence_node.*FAILED" "${SHAKE_RUN_LOG}"; then
+  echo "[FAIL] shake sequence reported failure (see log above); exiting non-zero."
+  exit 1
+fi
+echo "[Azas] shake sequence finished without failure markers."
diff --git a/tools/run/run_tmux_logic_sequence.sh b/tools/run/run_tmux_logic_sequence.sh
index 11fd41e..f33f6dc 100755
--- a/tools/run/run_tmux_logic_sequence.sh
+++ b/tools/run/run_tmux_logic_sequence.sh
@@ -129,15 +129,9 @@ ensure_collision_scene() {
       dispenser_collision_publish_objects:=true \
       dispenser_collision_publish_markers:=true &
     ros2 launch azas_bringup rg2_link6_tcp.launch.py publish_gripper_collision:=false &
+    # The RG2 mesh is now in the MoveIt URDF; purge the legacy attached box.
     timeout 12s ros2 run azas_motion link6_gripper_collision_node \
       --ros-args -p operation:=remove -p publish_once:=true -p publish_markers:=false || true
-    ros2 run azas_motion link6_gripper_collision_node \
-      --ros-args \
-      -p palm_size_x_m:=0.075 -p palm_size_y_m:=0.115 -p palm_size_z_m:=0.040 -p palm_z_m:=0.070 \
-      -p finger_size_x_m:=0.030 -p finger_size_y_m:=0.014 -p finger_size_z_m:=0.120 \
-      -p finger_y_m:=0.050 -p finger_z_m:=0.125 \
-      -p pad_size_x_m:=0.022 -p pad_size_y_m:=0.010 -p pad_size_z_m:=0.025 \
-      -p pad_y_m:=0.037 -p pad_z_m:=0.180 &
     ros2 run tf2_ros static_transform_publisher --x 0 --y 0 --z 0 --yaw 0 --pitch 0 --roll 0 --frame-id world --child-frame-id base_link &
     ros2 run azas_perception hand_eye_static_tf_node --ros-args -p compose_timeout_sec:=30.0 -p allow_direct_fallback:=false &
     python3 -m azas_motion.tumbler_collision_scene_node --ros-args -p action:=publish_detected -p object_id:=detected_tumbler -p use_lidded_height:=true
@@ -163,6 +157,7 @@ run_side_grip() {
       redetect_on_approach:=false redetect_settle_sec:=0.5 \
       grasp_mode:=side side_far_stage_enabled:=false side_approach_offset:=0.18 \
       side_short_stage_backoff_m:=0.08 side_grasp_stop_backoff_m:=0.04 side_close_underreach_m:=0.03 \
+      side_target_x_offset_m:="${SIDE_TARGET_X_OFFSET_M:--0.020}" \
       side_low_retry_lift_m:=0.0 side_low_retry_attempts:=0 \
       side_linear_approach_enabled:=true side_final_slide_enabled:=false \
       side_fixed_grasp_z_enabled:=false side_grasp_z_offset:=0.05 side_project_bbox_center_to_fixed_z:=false \
diff --git a/tools/run/show_measured_recipe_joint_preview_rviz.sh b/tools/run/show_measured_recipe_joint_preview_rviz.sh
index d44c972..66e9dc0 100755
--- a/tools/run/show_measured_recipe_joint_preview_rviz.sh
+++ b/tools/run/show_measured_recipe_joint_preview_rviz.sh
@@ -1,18 +1,33 @@
 #!/usr/bin/env bash
 set -euo pipefail
 
-# RViz-only measured joint preview.  This does not call Doosan motion or gripper
-# services; it only publishes /joint_states from calibration.yaml.
+# RViz-only measured joint preview.  This starts robot_state_publisher + RViz and
+# publishes /joint_states from calibration.yaml. It does not call Doosan motion,
+# MoveJoint, MoveLine, or gripper services.
 
 ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
 LOG_DIR="${LOG_DIR:-${ROOT_DIR}/log/manual}"
-RVIZ_CONFIG="${RVIZ_CONFIG:-${ROOT_DIR}/src/azas_bringup/rviz/azas_rule_motion_preview.rviz}"
+RVIZ_CONFIG="${RVIZ_CONFIG:-${ROOT_DIR}/src/azas_bringup/rviz/azas_dispenser_sequence_clean.rviz}"
+SAFETY_CONFIG="${SAFETY_CONFIG:-${ROOT_DIR}/src/azas_bringup/config/safety.yaml}"
+DISPENSER_COLLISION_CONFIG="${DISPENSER_COLLISION_CONFIG:-${ROOT_DIR}/src/azas_bringup/config/measured_dispenser_collision.yaml}"
+CALIBRATION_CONFIG="${CALIBRATION_CONFIG:-${ROOT_DIR}/src/azas_bringup/config/calibration.yaml}"
 ROBOT_COLOR="${ROBOT_COLOR:-white}"
-SHOW_WORKSPACE_SAFETY="${SHOW_WORKSPACE_SAFETY:-false}"
-SHOW_FULL_COLLISION_SCENE="${SHOW_FULL_COLLISION_SCENE:-false}"
+PUBLISH_RATE="${PUBLISH_RATE:-60.0}"
+SEGMENT_SECONDS="${SEGMENT_SECONDS:-4.0}"
+JOINT_VELOCITY_DEG_S="${JOINT_VELOCITY_DEG_S:-40.0}"
+HOLD_SECONDS="${HOLD_SECONDS:-1.0}"
+SHOW_WORKSPACE_SAFETY="${SHOW_WORKSPACE_SAFETY:-true}"
+SHOW_FULL_COLLISION_SCENE="${SHOW_FULL_COLLISION_SCENE:-true}"
 SHOW_MEASURED_DISPENSER_COLLISION="${SHOW_MEASURED_DISPENSER_COLLISION:-true}"
+SHOW_LINK6_GRIPPER="${SHOW_LINK6_GRIPPER:-true}"
+PUBLISH_WORKSPACE_COLLISION_OBJECTS="${PUBLISH_WORKSPACE_COLLISION_OBJECTS:-true}"
+PUBLISH_DISPENSER_COLLISION_OBJECTS="${PUBLISH_DISPENSER_COLLISION_OBJECTS:-true}"
+RESET_STALE_PREVIEW_NODES="${RESET_STALE_PREVIEW_NODES:-true}"
 START_FULL_COLLISION_MARKERS="${START_FULL_COLLISION_MARKERS:-false}"
 PREVIEW_ARGS=("$@")
+if [[ ${#PREVIEW_ARGS[@]} -gt 0 && "${PREVIEW_ARGS[0]}" != --* ]]; then
+  PREVIEW_ARGS=("--dispenser-ids" "${PREVIEW_ARGS[@]}")
+fi
 SESSION_NAME="${SESSION_NAME:-azas-measured-joint-preview}"
 
 mkdir -p "${LOG_DIR}"
@@ -52,26 +67,30 @@ export ROS_LOCALHOST_ONLY="${ROS_LOCALHOST_ONLY:-0}"
 export FASTDDS_BUILTIN_TRANSPORTS="${FASTDDS_BUILTIN_TRANSPORTS:-UDPv4}"
 
 pkill -f 'publish_measured_recipe_joint_rviz_preview.py' 2>/dev/null || true
+pkill -f 'preview_measured_dispenser_recipe_rviz.py' 2>/dev/null || true
 pkill -f 'rule_motion_joint_preview_node' 2>/dev/null || true
 pkill -f 'm0609_shake_joint_state_node' 2>/dev/null || true
+if [[ "${RESET_STALE_PREVIEW_NODES}" == "true" || "${RESET_STALE_PREVIEW_NODES}" == "1" ]]; then
+  pkill -f 'dispenser_sequence_preview_node' 2>/dev/null || true
+  pkill -f 'workspace_collision_scene_node' 2>/dev/null || true
+  pkill -f 'measured_dispenser_collision_scene_node' 2>/dev/null || true
+  pkill -f 'collision_scene_rviz_publisher' 2>/dev/null || true
+  pkill -f 'link6_gripper_collision_node' 2>/dev/null || true
+  pkill -f '__node:=m0609_robot_state_publisher' 2>/dev/null || true
+fi
 
-ros2 launch azas_bringup hardware_free_demo.launch.py \
+ros2 launch "${ROOT_DIR}/src/azas_bringup/launch/measured_joint_preview_display.launch.py" \
   use_rviz:=false \
-  use_robot_urdf:=true \
   robot_color:="${ROBOT_COLOR}" \
-  enable_ik_preview:=false \
-  run_live_stt:=false \
-  run_recipe_mapper:=false \
-  use_llm:=false \
-  show_sequence_markers:=false \
-  show_dispenser_markers:=false \
-  show_animated_cup:=false \
-  show_demo_arm:=false \
   show_workspace_safety:="${SHOW_WORKSPACE_SAFETY}" \
   show_measured_dispenser_collision:="${SHOW_MEASURED_DISPENSER_COLLISION}" \
   show_full_collision_scene:="${SHOW_FULL_COLLISION_SCENE}" \
-  show_link6_gripper:=true \
-  enable_rule_joint_preview:=false \
+  show_link6_gripper:="${SHOW_LINK6_GRIPPER}" \
+  publish_workspace_collision_objects:="${PUBLISH_WORKSPACE_COLLISION_OBJECTS}" \
+  publish_dispenser_collision_objects:="${PUBLISH_DISPENSER_COLLISION_OBJECTS}" \
+  safety_config_path:="${SAFETY_CONFIG}" \
+  dispenser_collision_config_path:="${DISPENSER_COLLISION_CONFIG}" \
+  calibration_path:="${CALIBRATION_CONFIG}" \
   >"${LOG_DIR}/measured_joint_preview_description.log" 2>&1 &
 DESC_PID=$!
 
@@ -82,7 +101,12 @@ if [[ "${START_FULL_COLLISION_MARKERS}" == "true" ]]; then
   COLLISION_PID=$!
 fi
 
-python3 tools/run/publish_measured_recipe_joint_rviz_preview.py "${PREVIEW_ARGS[@]}" \
+python3 tools/run/preview_measured_dispenser_recipe_rviz.py \
+  --rate-hz "${PUBLISH_RATE}" \
+  --segment-seconds "${SEGMENT_SECONDS}" \
+  --joint-velocity-deg-s "${JOINT_VELOCITY_DEG_S}" \
+  --hold-seconds "${HOLD_SECONDS}" \
+  "${PREVIEW_ARGS[@]}" \
   >"${LOG_DIR}/measured_joint_preview_joints.log" 2>&1 &
 JOINT_PID=$!
 
@@ -93,6 +117,10 @@ RVIZ_PID=$!
 echo "[Azas] RViz measured joint preview started."
 echo "[Azas] Session marker: ${SESSION_NAME}"
 echo "[Azas] Args: ${PREVIEW_ARGS[*]:-(default recipe/color map)}"
+echo "[Azas] safety_config=${SAFETY_CONFIG}"
+echo "[Azas] dispenser_collision_config=${DISPENSER_COLLISION_CONFIG}"
+echo "[Azas] calibration_config=${CALIBRATION_CONFIG}"
+echo "[Azas] preview_joint_velocity_deg_s=${JOINT_VELOCITY_DEG_S}"
 echo "[Azas] PIDs: description=${DESC_PID} collision=${COLLISION_PID} joints=${JOINT_PID} rviz=${RVIZ_PID}"
 echo "[Azas] Logs: ${LOG_DIR}/measured_joint_preview_*.log"
 
diff --git a/tools/run/stop_azas_all.sh b/tools/run/stop_azas_all.sh
index ee6678a..1be0ecd 100755
--- a/tools/run/stop_azas_all.sh
+++ b/tools/run/stop_azas_all.sh
@@ -39,8 +39,11 @@ self_and_ancestors() {
 PROTECTED_PIDS=" $(self_and_ancestors | tr '\n' ' ') "
 
 collect_pids() {
-  ps -eo pid=,args= | grep -E "${ROS_PATTERN}" | grep -Ev "${PROTECT_PATTERN}" \
-    | while read -r pid args; do
+  ps -eo pid=,stat=,args= | grep -E "${ROS_PATTERN}" | grep -Ev "${PROTECT_PATTERN}" \
+    | while read -r pid stat args; do
+        # Defunct children cannot be killed; counting them as live ROS processes
+        # prevents FastDDS SHM cleanup and makes reconnect look stuck.
+        [[ "${stat}" == Z* ]] && continue
         [[ "${PROTECTED_PIDS}" == *" ${pid} "* ]] && continue
         echo "${pid}"
       done
diff --git a/tools/run/wait_for_lid_grip_status.py b/tools/run/wait_for_lid_grip_status.py
new file mode 100755
index 0000000..16c998c
--- /dev/null
+++ b/tools/run/wait_for_lid_grip_status.py
@@ -0,0 +1,93 @@
+#!/usr/bin/env python3
+"""Wait for the supervised lid-grip/twist sequence to report success.
+
+The lid-grip launch keeps its OpenCV/perception nodes alive after a successful
+`p`-triggered sequence.  Panel shell chaining therefore needs a small ROS topic
+gate that exits as soon as the planner publishes its terminal success/failure
+status instead of waiting for the operator to close the preview window.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import time
+
+import rclpy
+from rclpy.node import Node
+from std_msgs.msg import String
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Wait for /jarvis/lid_gripper/status success/failure JSON."
+    )
+    parser.add_argument("--topic", default="/jarvis/lid_gripper/status")
+    parser.add_argument("--timeout-sec", type=float, default=900.0)
+    parser.add_argument(
+        "--success-status",
+        action="append",
+        default=["motion_sequence_requested"],
+        help="status value that means the lid close sequence completed successfully",
+    )
+    parser.add_argument(
+        "--failure-status",
+        action="append",
+        default=["failed"],
+        help="status value that means the lid close sequence failed",
+    )
+    return parser.parse_args()
+
+
+class LidGripStatusWaiter(Node):
+    def __init__(self, topic: str, success_statuses: set[str], failure_statuses: set[str]):
+        super().__init__("azas_wait_for_lid_grip_status")
+        self._success_statuses = success_statuses
+        self._failure_statuses = failure_statuses
+        self.result_code: int | None = None
+        self.result_text = ""
+        self.create_subscription(String, topic, self._on_status, 10)
+        print(f"[Azas] waiting for lid grip status on {topic}", flush=True)
+
+    def _on_status(self, msg: String) -> None:
+        try:
+            payload = json.loads(msg.data)
+        except json.JSONDecodeError:
+            payload = {"status": msg.data}
+        status = str(payload.get("status", "")).strip()
+        if not status:
+            return
+        print(f"[Azas] lid_grip_status={status} payload={payload}", flush=True)
+        if status in self._success_statuses:
+            self.result_code = 0
+            self.result_text = f"success status observed: {status}"
+        elif status in self._failure_statuses:
+            self.result_code = 1
+            self.result_text = f"failure status observed: {status}"
+
+
+def main() -> int:
+    args = parse_args()
+    success_statuses = {str(item) for item in args.success_status}
+    failure_statuses = {str(item) for item in args.failure_status}
+    timeout_sec = max(float(args.timeout_sec), 0.1)
+
+    rclpy.init(args=None)
+    node = LidGripStatusWaiter(args.topic, success_statuses, failure_statuses)
+    deadline = time.monotonic() + timeout_sec
+    try:
+        while rclpy.ok() and node.result_code is None and time.monotonic() < deadline:
+            rclpy.spin_once(node, timeout_sec=0.1)
+        if node.result_code is not None:
+            print(f"[Azas] {node.result_text}", flush=True)
+            return node.result_code
+        print(f"[Azas][FAIL] lid grip status wait timed out after {timeout_sec:.1f}s", flush=True)
+        return 2
+    finally:
+        node.destroy_node()
+        if rclpy.ok():
+            rclpy.shutdown()
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/tools/smoke/smoke_cocktail_dryrun_sequence.py b/tools/smoke/smoke_cocktail_dryrun_sequence.py
index 1921219..05163b9 100755
--- a/tools/smoke/smoke_cocktail_dryrun_sequence.py
+++ b/tools/smoke/smoke_cocktail_dryrun_sequence.py
@@ -81,10 +81,14 @@ def main() -> int:
     deadline = time.monotonic() + 8.0
 
     # Let discovery connect before publishing the one-shot inputs.
-    while time.monotonic() < deadline and node.count_publishers("/azas/cocktail/status") == 0:
+    while time.monotonic() < deadline and (
+        node.count_publishers("/azas/cocktail/status") == 0
+        or node.count_subscribers("/azas/cup_detection") == 0
+        or node.count_subscribers("/azas/voice/recipe_decision") == 0
+    ):
         rclpy.spin_once(node, timeout_sec=0.1)
 
-    for _ in range(5):
+    for _ in range(10):
         # The cocktail dry-run planner consumes symbolic cup/lid presence only.
         # Motion-facing cup poses are produced by the perception bridge from
         # live statuses that start with "detected:upright"; this smoke does not
@@ -93,8 +97,14 @@ def main() -> int:
         node.publish_detection("detected:lid bbox=80x80 depth_raw=260.0")
         rclpy.spin_once(node, timeout_sec=0.1)
 
-    node.publish_decision()
+    next_publish = 0.0
     while time.monotonic() < deadline:
+        now = time.monotonic()
+        if now >= next_publish:
+            node.publish_detection("detected:cup bbox=100x100 depth_raw=300.0")
+            node.publish_detection("detected:lid bbox=80x80 depth_raw=260.0")
+            node.publish_decision()
+            next_publish = now + 0.5
         rclpy.spin_once(node, timeout_sec=0.1)
         if node.saw_complete():
             required_phases = {
@@ -118,7 +128,7 @@ def main() -> int:
             node.destroy_node()
             rclpy.shutdown()
             return 0
-        if node.saw_blocked():
+        if node.saw_blocked() and not node.latest_plan_phases():
             print("[FAIL] cocktail dry-run sequence blocked")
             for item in node._statuses:
                 print(json.dumps(item, ensure_ascii=False))
diff --git a/tools/smoke/smoke_one_click_cocktail_no_motion.sh b/tools/smoke/smoke_one_click_cocktail_no_motion.sh
index 8004803..aaa7201 100755
--- a/tools/smoke/smoke_one_click_cocktail_no_motion.sh
+++ b/tools/smoke/smoke_one_click_cocktail_no_motion.sh
@@ -94,9 +94,13 @@ grep -q -- 'grouped_press_counts=1x2' "${TMP_OUT}"
 cat >"${RESULT_LOG}" <<'LOG'
 [Azas] RG2 full-open release complete; continuing only after open settle wait
 [Azas] RG2 close empty gripper for dispenser press: sent RG2 set_width command width_units=0 force_units=300
-[Azas] move to measured press contact joints exactly: joints_deg=[15.12, 40.50, 32.87, -33.75, 51.99, 28.07]
-[Azas] press dispenser pump 1/2: posx=[1,2,3,4,5,6]
-[Azas] press dispenser pump 2/2: posx=[1,2,3,4,5,6]
+[Azas] PRESS_PRE measured press pre-contact joints: movej_deg=[-4.5, 26.0, 74.2, 146.7, 10.7, -142.0]
+[Azas] PRESS_CONTACT measured contact joints 1/2: movej_deg=[10.8, 30.9, 57.9, -38.2, 25.1, 32.9]
+[Azas] PRESS_Z_OVERDRIVE from measured contact 1/2: posx=[1,2,3,4,5,6]
+[Azas] return to PRESS_CONTACT after Z overdrive 1/2: posx=[1,2,3,4,5,6]
+[Azas] PRESS_CONTACT measured contact joints 2/2: movej_deg=[10.8, 30.9, 57.9, -38.2, 25.1, 32.9]
+[Azas] PRESS_Z_OVERDRIVE from measured contact 2/2: posx=[1,2,3,4,5,6]
+[Azas] return to PRESS_CONTACT after Z overdrive 2/2: posx=[1,2,3,4,5,6]
 [Azas] RG2 soft side-grasp: sent RG2 set_width command width_units=750 force_units=250
 [Azas] post-grasp lift: posx=[1,2,3,4,5,6]
 [PASS] measured dispenser recipe sequence completed
@@ -108,23 +112,25 @@ from pathlib import Path
 import importlib.util
 import yaml
 
-expected_press_joints = {
-    "1": [15.12, 40.50, 32.87, -33.75, 51.99, 28.07],
-    "2": [6.36, 39.76, 30.07, -14.08, 55.67, 27.99],
-    "3": [-0.29, 40.29, 28.38, -5.98, 55.25, 14.33],
-    "4": [-7.04, 40.77, 28.37, 4.55, 54.02, 0.22],
-}
-
 calibration = yaml.safe_load(Path('src/azas_bringup/config/calibration.yaml').read_text())
-for dispenser_id, expected in expected_press_joints.items():
-    actual = calibration['dispenser_outlets'][dispenser_id]['press_contact_joints_deg']
-    assert len(actual) == 6, (dispenser_id, actual)
-    assert all(abs(float(a) - e) < 1e-6 for a, e in zip(actual, expected)), (dispenser_id, actual, expected)
+for dispenser_id in ("1", "2", "3", "4"):
+    outlet = calibration['dispenser_outlets'][dispenser_id]
+    for key in (
+        'cup_pre_place_joints_deg',
+        'cup_place_joints_deg',
+        'press_pre_joints_deg',
+        'press_contact_joints_deg',
+    ):
+        actual = outlet[key]
+        assert len(actual) == 6, (dispenser_id, key, actual)
+        assert all(isinstance(float(value), float) for value in actual), (dispenser_id, key, actual)
 
 recipe_source = Path('tools/run/run_measured_dispenser_recipe_sequence.py').read_text()
-assert 'default=False' in recipe_source and '--press-move-configured-prepose-before-joint' in recipe_source
-assert 'measured press contact joints are authoritative' in recipe_source
-print('[Azas smoke] measured press joints and joint-first press path OK')
+assert 'default=False' in recipe_source and '--press-reset-before-press' in recipe_source
+assert 'PRESS_Z_OVERDRIVE -> PRESS_CONTACT -> PRESS_PRE' in recipe_source
+assert 'contact_joints is not None and (skip_measured_press_pre or pre_joints is not None)' in recipe_source
+assert 'Fallback-only option for old contact-joint mode' in recipe_source
+print('[Azas smoke] measured PRE/CONTACT joint-first press path OK')
 
 path = Path('tools/run/robot_pipeline_control_server.py')
 spec = importlib.util.spec_from_file_location('robot_pipeline_control_server', path)
diff --git a/tools/smoke/smoke_voice_cocktail_no_hardware.py b/tools/smoke/smoke_voice_cocktail_no_hardware.py
index 6f191da..a200dd1 100644
--- a/tools/smoke/smoke_voice_cocktail_no_hardware.py
+++ b/tools/smoke/smoke_voice_cocktail_no_hardware.py
@@ -61,14 +61,17 @@ def main() -> int:
     while time.monotonic() < deadline and (
         node.count_subscribers("/stt_result") == 0
         or node.count_publishers("/azas/cocktail/status") == 0
+        or node.count_publishers("/azas/voice/recipe_decision") == 0
+        or node.count_subscribers("/azas/voice/recipe_decision") < 2
     ):
         rclpy.spin_once(node, timeout_sec=0.1)
 
-    for _ in range(3):
-        node.publish_stt(text)
-        rclpy.spin_once(node, timeout_sec=0.1)
-
+    next_publish = 0.0
     while time.monotonic() < deadline:
+        now = time.monotonic()
+        if now >= next_publish:
+            node.publish_stt(text)
+            next_publish = now + 0.5
         rclpy.spin_once(node, timeout_sec=0.1)
         if node.saw_complete():
             decision = node.latest_decision()
@@ -83,7 +86,7 @@ def main() -> int:
             node.destroy_node()
             rclpy.shutdown()
             return 0
-        if node.saw_blocked():
+        if node.saw_blocked() and not node._plans:
             print("[FAIL] cocktail dry-run blocked")
             for item in node._statuses:
                 print(json.dumps(item, ensure_ascii=False))