fix(044): hand rect edit stability

- Use keypoint BBox as transform refRect (canvas coords)
- Unify resolution source (metadata.resolution → resolution → 512)
- Clamp relative ratios to 0–1 to avoid overshoot/flip
- Convert rect move delta from canvas→data coords
- Remove wrong ‘hands are canvas coords’ assumption
- Gate debug logs via window.poseEditorDebug

Hands’ resize now follows direction/amount like face ✅🖐️

.gitignore

@@ -115,4 +115,4 @@ development_tests/
 issues/
 CLAUDE.md
 .claude/
-
+AGENTS.md

static/pose_editor.js

@@ -1,5 +1,12 @@
 // Canvas操作用JavaScript for dwpose-editor
 
+// 🔧 最小限デバッグフラグ（必要時のみONにする）
+window.poseEditorDebug = window.poseEditorDebug || {
+    rect: false,
+    hands: false,
+    send: false
+};
+
 // グローバル変数
 window.poseEditorGlobals = {
     canvas: null,
@@ -593,6 +600,12 @@ function handleMouseDown(event) {
                 const currentRect = window.poseEditorGlobals.currentRects[rectType];
                 if (currentRect) {
                     window.poseEditorGlobals.originalRect = { ...currentRect };
+                    // 🔧 このドラッグ操作の基準となる"元キーポイント"も現在の状態からスナップショット
+                    //    以前はセッション開始時のベースを使っていたため、連続リサイズで倍率/方向が狂っていた
+                    const currentPoseData = window.poseEditorGlobals.poseData || poseData;
+                    if (currentPoseData) {
+                        window.poseEditorGlobals.originalKeypoints = JSON.parse(JSON.stringify(currentPoseData));
+                    }
                 }
                 
                 // コントロールポイントドラッグ（リサイズ）
@@ -1056,11 +1069,13 @@ function transformKeypointsDirectly(rectType, originalRect, newRect) {
     const canvasWidth = window.poseEditorGlobals.canvas ? window.poseEditorGlobals.canvas.width : 512;
     const canvasHeight = window.poseEditorGlobals.canvas ? window.poseEditorGlobals.canvas.height : 512;
     
-    let dataResolutionWidth = canvasWidth;
-    let dataResolutionHeight = canvasHeight;
-    
-    // 解像度情報の取得
-    if (currentPoseData.resolution && Array.isArray(currentPoseData.resolution) && currentPoseData.resolution.length >= 2) {
+    // 解像度情報の取得（metadata.resolution → resolution → 512x512）
+    let dataResolutionWidth = 512;
+    let dataResolutionHeight = 512;
+    if (currentPoseData.metadata && currentPoseData.metadata.resolution && Array.isArray(currentPoseData.metadata.resolution) && currentPoseData.metadata.resolution.length >= 2) {
+        dataResolutionWidth = currentPoseData.metadata.resolution[0];
+        dataResolutionHeight = currentPoseData.metadata.resolution[1];
+    } else if (currentPoseData.resolution && Array.isArray(currentPoseData.resolution) && currentPoseData.resolution.length >= 2) {
         dataResolutionWidth = currentPoseData.resolution[0];
         dataResolutionHeight = currentPoseData.resolution[1];
     }
@@ -1068,21 +1083,87 @@ function transformKeypointsDirectly(rectType, originalRect, newRect) {
     const coordScaleX = canvasWidth / dataResolutionWidth;
     const coordScaleY = canvasHeight / dataResolutionHeight;
     
-    // 正規化座標かピクセル座標かを判定
+    // 正規化/ピクセル/Canvas座標を判定（元データ優先で判定）
     let isNormalized = false;
-    if (targetKeypoints.length > 0) {
-        for (let i = 0; i < targetKeypoints.length; i += 3) {
-            if (i + 2 < targetKeypoints.length && targetKeypoints[i + 2] > 0) {
-                const x = targetKeypoints[i];
-                const y = targetKeypoints[i + 1];
-                isNormalized = (x >= 0 && x <= 1 && y >= 0 && y <= 1);
-                break;
+    let isCanvasUnit = false;
+    let sampleX = null, sampleY = null;
+    if (originalTargetKeypoints.length > 0) {
+        let overCanvasCount = 0;
+        let validCount = 0;
+        for (let i = 0; i < originalTargetKeypoints.length; i += 3) {
+            if (i + 2 < originalTargetKeypoints.length && originalTargetKeypoints[i + 2] > 0) {
+                const x = originalTargetKeypoints[i];
+                const y = originalTargetKeypoints[i + 1];
+                if (sampleX === null) { sampleX = x; sampleY = y; }
+                validCount++;
+                if (x > dataResolutionWidth * 1.01 || y > dataResolutionHeight * 1.01) {
+                    overCanvasCount++;
+                }
+                // 正規化判定
+                if (x >= 0 && x <= 1 && y >= 0 && y <= 1) {
+                    isNormalized = true;
+                    break;
+                }
+                if (validCount >= 20) break; // サンプル十分
             }
         }
+        if (!isNormalized && validCount > 0) {
+            // 多数がデータ解像度を超える場合はCanvas座標とみなす
+            isCanvasUnit = (overCanvasCount / validCount) > 0.5;
+        }
     }
     
+    // 🔍 デバッグログ: 手と顔の座標データ比較
+    if (window.poseEditorDebug.rect) console.log(`🔍 [DEBUG ${rectType}] 座標データ分析:`, {
+        rectType: rectType,
+        isNormalized: isNormalized,
+        isCanvasUnit: isCanvasUnit,
+        sampleCoord: { x: sampleX, y: sampleY },
+        originalRect: { x: originalRect.x, y: originalRect.y, width: originalRect.width, height: originalRect.height },
+        newRect: { x: newRect.x, y: newRect.y, width: newRect.width, height: newRect.height },
+        coordScale: { x: coordScaleX, y: coordScaleY },
+        resolution: { data: dataResolutionWidth + 'x' + dataResolutionHeight, canvas: canvasWidth + 'x' + canvasHeight },
+        keypointsLength: targetKeypoints.length
+    });
+    
     
+    // 参照矩形は常にポイント群のBBox（Canvas座標）を使用して相対比を安定化
+    let refRect = (function () {
+        let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+        for (let i = 0; i < originalTargetKeypoints.length; i += 3) {
+            if (i + 2 >= originalTargetKeypoints.length) break;
+            const conf = originalTargetKeypoints[i + 2];
+            if (conf > 0.1) {
+                let x = originalTargetKeypoints[i];
+                let y = originalTargetKeypoints[i + 1];
+                let cx, cy;
+                if (isNormalized) {
+                    cx = (x * dataResolutionWidth) * coordScaleX;
+                    cy = (y * dataResolutionHeight) * coordScaleY;
+                } else if (isCanvasUnit) {
+                    cx = x; cy = y;
+                } else {
+                    cx = x * coordScaleX;
+                    cy = y * coordScaleY;
+                }
+                minX = Math.min(minX, cx);
+                minY = Math.min(minY, cy);
+                maxX = Math.max(maxX, cx);
+                maxY = Math.max(maxY, cy);
+            }
+        }
+        const margin = 8;
+        const bx = isFinite(minX) ? minX - margin : originalRect.x;
+        const by = isFinite(minY) ? minY - margin : originalRect.y;
+        const bw = (isFinite(maxX) && isFinite(minX)) ? (maxX - minX) + margin * 2 : originalRect.width;
+        const bh = (isFinite(maxY) && isFinite(minY)) ? (maxY - minY) + margin * 2 : originalRect.height;
+        const rr = { x: bx, y: by, width: Math.max(1, bw), height: Math.max(1, bh) };
+        if (window.poseEditorDebug.rect) console.log('🔧 [transformKeypointsDirectly] Using bbox as refRect', { refRect: rr, originalRect });
+        return rr;
+    })();
+
     // キーポイントを一括変換（元データから毎回変換）
+    let debugSampleIndex = -1;
     for (let i = 0; i < originalTargetKeypoints.length; i += 3) {
         if (i + 2 < originalTargetKeypoints.length && i + 2 < targetKeypoints.length) {
             const confidence = originalTargetKeypoints[i + 2];
@@ -1091,38 +1172,89 @@ function transformKeypointsDirectly(rectType, originalRect, newRect) {
                 let x = originalTargetKeypoints[i];
                 let y = originalTargetKeypoints[i + 1];
                 
-                // データ座標→Canvas座標
+                // データ座標→Canvas座標（入力の座標系に応じて）
                 let canvasX, canvasY;
                 if (isNormalized) {
                     canvasX = (x * dataResolutionWidth) * coordScaleX;
                     canvasY = (y * dataResolutionHeight) * coordScaleY;
+                } else if (isCanvasUnit) {
+                    // 既にCanvas座標（過去のバグで混入している場合）
+                    canvasX = x;
+                    canvasY = y;
                 } else {
                     canvasX = x * coordScaleX;
                     canvasY = y * coordScaleY;
                 }
                 
-                // 元矩形内での相対位置を計算
-                const relativeX = (canvasX - originalRect.x) / originalRect.width;
-                const relativeY = (canvasY - originalRect.y) / originalRect.height;
-                
+                // 元矩形内での相対位置を計算（参照矩形に対して）
+                let relativeX = (canvasX - refRect.x) / refRect.width;
+                let relativeY = (canvasY - refRect.y) / refRect.height;
+                // 安定化のために0-1へクランプ
+                relativeX = Math.max(0, Math.min(1, relativeX));
+                relativeY = Math.max(0, Math.min(1, relativeY));
+
                 // 新矩形での新しい位置を計算
                 const newCanvasX = newRect.x + (relativeX * newRect.width);
                 const newCanvasY = newRect.y + (relativeY * newRect.height);
                 
-                // Canvas座標→データ座標に戻す
+                // Canvas座標→データ座標に戻す（常にデータ座標で保存）
+                let finalX, finalY;
                 if (isNormalized) {
                     const dataX = newCanvasX / coordScaleX;
                     const dataY = newCanvasY / coordScaleY;
-                    targetKeypoints[i] = dataX / dataResolutionWidth;
-                    targetKeypoints[i + 1] = dataY / dataResolutionHeight;
+                    finalX = dataX / dataResolutionWidth;
+                    finalY = dataY / dataResolutionHeight;
+                    targetKeypoints[i] = finalX;
+                    targetKeypoints[i + 1] = finalY;
                 } else {
-                    targetKeypoints[i] = newCanvasX / coordScaleX;
-                    targetKeypoints[i + 1] = newCanvasY / coordScaleY;
+                    finalX = newCanvasX / coordScaleX;
+                    finalY = newCanvasY / coordScaleY;
+                    targetKeypoints[i] = finalX;
+                    targetKeypoints[i + 1] = finalY;
+                }
+                
+                // 🔍 最初のサンプルポイントのみ詳細ログ出力
+                if (debugSampleIndex < 0) {
+                    debugSampleIndex = i / 3;
+                    if (window.poseEditorDebug.rect) console.log(`🔍 [DEBUG ${rectType}] 座標変換詳細 (Point ${debugSampleIndex}):`, {
+                        originalData: { x: x, y: y },
+                        canvasCoord: { x: canvasX, y: canvasY },
+                        relative: { x: relativeX, y: relativeY },
+                        newCanvas: { x: newCanvasX, y: newCanvasY },
+                        finalData: { x: finalX, y: finalY },
+                        deltaCanvas: { x: newCanvasX - canvasX, y: newCanvasY - canvasY },
+                        deltaData: { x: finalX - x, y: finalY - y }
+                    });
                 }
             }
         }
     }
     
+    // 🔍 手のデータの場合：変換前後の全データ比較ログ
+    if (rectType === 'leftHand' || rectType === 'rightHand') {
+        if (window.poseEditorDebug.rect) console.log(`🔍 [${rectType}] 変換前後データ比較:`, {
+            rectType: rectType,
+            originalFirstPoint: originalTargetKeypoints.length >= 3 ? 
+                { x: originalTargetKeypoints[0], y: originalTargetKeypoints[1], conf: originalTargetKeypoints[2] } : null,
+            transformedFirstPoint: targetKeypoints.length >= 3 ? 
+                { x: targetKeypoints[0], y: targetKeypoints[1], conf: targetKeypoints[2] } : null,
+            originalSample3Points: [
+                originalTargetKeypoints.slice(0, 9),  // 最初の3点
+                originalTargetKeypoints.slice(18, 27), // 中間3点
+                originalTargetKeypoints.slice(54, 63)  // 最後の3点
+            ],
+            transformedSample3Points: [
+                targetKeypoints.slice(0, 9),  // 最初の3点
+                targetKeypoints.slice(18, 27), // 中間3点
+                targetKeypoints.slice(54, 63)  // 最後の3点
+            ],
+            coordinateShift: targetKeypoints.length >= 3 ? {
+                deltaX: targetKeypoints[0] - originalTargetKeypoints[0],
+                deltaY: targetKeypoints[1] - originalTargetKeypoints[1]
+            } : null
+        });
+    }
+    
 }
 
 // 🔧 元座標からキーポイントを移動（累積移動防止版）
@@ -1285,13 +1417,32 @@ function moveKeypointsWithRect(rectType, deltaX, deltaY) {
         return;
     }
     
-    // すべてのキーポイントを移動（refs方式）
+    // Canvas→データ座標への変換係数
+    let dataResolutionWidth = 512;
+    let dataResolutionHeight = 512;
+    if (currentPoseData.metadata && currentPoseData.metadata.resolution && Array.isArray(currentPoseData.metadata.resolution) && currentPoseData.metadata.resolution.length >= 2) {
+        dataResolutionWidth = currentPoseData.metadata.resolution[0];
+        dataResolutionHeight = currentPoseData.metadata.resolution[1];
+    } else if (currentPoseData.resolution && Array.isArray(currentPoseData.resolution) && currentPoseData.resolution.length >= 2) {
+        dataResolutionWidth = currentPoseData.resolution[0];
+        dataResolutionHeight = currentPoseData.resolution[1];
+    }
+    const canvasWidth = window.poseEditorGlobals.canvas ? window.poseEditorGlobals.canvas.width : 512;
+    const canvasHeight = window.poseEditorGlobals.canvas ? window.poseEditorGlobals.canvas.height : 512;
+    const coordScaleX = canvasWidth / dataResolutionWidth;
+    const coordScaleY = canvasHeight / dataResolutionHeight;
+    
+    // Canvasの移動量→データ座標の移動量へ変換
+    const dataDeltaX = deltaX / coordScaleX;
+    const dataDeltaY = deltaY / coordScaleY;
+
+    // すべてのキーポイントを移動（データ座標系）
     for (let i = 0; i < keypoints.length; i += 3) {
         const confidence = keypoints[i + 2];
         
         if (confidence > 0.1) {  // 有効なキーポイントのみ移動
-            keypoints[i] += deltaX;      // X座標
-            keypoints[i + 1] += deltaY;  // Y座標
+            keypoints[i] += dataDeltaX;      // X座標（データ座標）
+            keypoints[i + 1] += dataDeltaY;  // Y座標（データ座標）
         }
     }
     
@@ -1554,10 +1705,10 @@ function syncBodiesToPeople(poseData) {
 
 // Gradioにデータ送信（refs互換・強制changeイベント版）
 function sendPoseDataToGradio() {
-    console.log('🔍 [sendPoseDataToGradio] Called');
+    if (window.poseEditorDebug.send) console.log('🔍 [sendPoseDataToGradio] Called');
     // グローバルposeDataを参照
     const currentPoseData = window.poseEditorGlobals.poseData || poseData;
-    console.log('🔍 [sendPoseDataToGradio] currentPoseData state:', {
+    if (window.poseEditorDebug.send) console.log('🔍 [sendPoseDataToGradio] currentPoseData state:', {
         exists: !!currentPoseData,
         hasPeople: !!currentPoseData?.people,
         peopleCount: currentPoseData?.people?.length || 0,
@@ -1677,7 +1828,7 @@ function sendPoseDataToGradio() {
         }
         
         // 送信前の最終データ確認
-        console.log('🔍 [sendPoseDataToGradio] Final canvasData being sent:', {
+        if (window.poseEditorDebug.send) console.log('🔍 [sendPoseDataToGradio] Final canvasData being sent:', {
             hasPeople: !!canvasData.people,
             peopleCount: canvasData.people?.length || 0,
             hasHandLeft: !!canvasData.people?.[0]?.hand_left_keypoints_2d,
@@ -1689,7 +1840,7 @@ function sendPoseDataToGradio() {
         });
         
         const jsonString = JSON.stringify(canvasData);
-        console.log('🎯 [sendPoseDataToGradio] People形式でGradioに送信:', canvasData.people.length, 'people');
+        if (window.poseEditorDebug.send) console.log('🎯 [sendPoseDataToGradio] People形式でGradioに送信:', canvasData.people.length, 'people');
         
         // 専用の隠しテキストボックスを探して更新
         const jsUpdateTextbox = document.querySelector('#js_pose_update textarea');
@@ -1778,7 +1929,7 @@ function drawPose(poseData, enableHands = true, enableFace = true, highlightInde
                 ];
                 
                 // 🔧 Issue #043: 手データのデバッグ情報追加
-                console.log('🫳 Hand data debug:', {
+                if (window.poseEditorDebug.hands) console.log('🫳 Hand data debug:', {
                     enableHands: enableHands,
                     leftHandLength: handsDataForDrawing[0].length,
                     rightHandLength: handsDataForDrawing[1].length,
@@ -1788,14 +1939,14 @@ function drawPose(poseData, enableHands = true, enableFace = true, highlightInde
             // 💖 people形式のみサポート、古いhands形式は削除
             } else {
                 handsDataForDrawing = [[], []]; // 空の手データ
-                console.log('🚫 No people data available for hands');
+                if (window.poseEditorDebug.hands) console.log('🚫 No people data available for hands');
             }
             
             if (handsDataForDrawing && handsDataForDrawing.length >= 2) {
-                console.log('✅ Calling drawHands function');
+                if (window.poseEditorDebug.hands) console.log('✅ Calling drawHands function');
                 drawHands(handsDataForDrawing, originalRes, scaleX, scaleY);
             } else {
-                console.log('❌ Invalid hands data for drawing');
+                if (window.poseEditorDebug.hands) console.log('❌ Invalid hands data for drawing');
             }
         } catch (error) {
             console.error("❌ Error drawing hands:", error);
@@ -2623,13 +2774,16 @@ function calculateHandRect(handData, originalRes, scaleX, scaleY) {
         const confidence = handData[i + 2];
         
         if (confidence > 0.3) { // refs互換の閾値
-            const scaledX = x * scaleX;
-            const scaledY = y * scaleY;
-            
-            minX = Math.min(minX, scaledX);
-            minY = Math.min(minY, scaledY);
-            maxX = Math.max(maxX, scaledX);
-            maxY = Math.max(maxY, scaledY);
+            // 🔧 手のキーポイント描画と完全に統一した座標変換
+            // drawHands関数では scaledX = x * scaleX しているため、
+            // 矩形計算でも同じ変換を適用して座標系を統一
+            const finalX = x * scaleX;
+            const finalY = y * scaleY;
+            
+            minX = Math.min(minX, finalX);
+            minY = Math.min(minY, finalY);
+            maxX = Math.max(maxX, finalX);
+            maxY = Math.max(maxY, finalY);
             validPointCount++;
         }
     }
@@ -2638,12 +2792,61 @@ function calculateHandRect(handData, originalRes, scaleX, scaleY) {
     
     // 10px余白付きで矩形返却（refs互換）
     const margin = 10;
-    return {
+    const rect = {
         x: minX - margin,
         y: minY - margin,
         width: (maxX - minX) + (margin * 2),
         height: (maxY - minY) + (margin * 2)
     };
+    
+    // 🔍 デバッグログ: 手の矩形計算結果
+    const canvas = window.poseEditorGlobals.canvas;
+    
+    // 🔍 全キーポイントの詳細ログを追加
+    const allPoints = [];
+    for (let i = 0; i < handData.length; i += 3) {
+        if (i + 2 < handData.length && handData[i + 2] > 0.3) {
+            allPoints.push({
+                index: i / 3,
+                x: handData[i],
+                y: handData[i + 1],
+                confidence: handData[i + 2]
+            });
+        }
+    }
+    
+    if (window.poseEditorDebug.rect) console.log(`🔍 [calculateHandRect] 矩形計算結果:`, {
+        rawBounds: { minX, minY, maxX, maxY },
+        finalRect: rect,
+        validPointCount,
+        firstPoint: handData.length >= 3 ? { x: handData[0], y: handData[1], conf: handData[2] } : null,
+        scaleFactors: { scaleX, scaleY },
+        coordinateDetection: handData[0] > 10 ? 'ピクセル座標' : '正規化座標',
+        canvasInfo: canvas ? {
+            width: canvas.width,
+            height: canvas.height,
+            clientWidth: canvas.clientWidth,
+            clientHeight: canvas.clientHeight,
+            scale: canvas.width / canvas.clientWidth
+        } : 'Canvas未取得'
+    });
+    
+    // 🔍 キーポイント座標を詳細表示
+    if (window.poseEditorDebug.rect) console.log(`🔍 [calculateHandRect] 全有効キーポイント座標:`, allPoints);
+    
+    // 🔍 座標の範囲をさらに詳細分析
+    const xCoords = allPoints.map(p => p.x);
+    const yCoords = allPoints.map(p => p.y);
+    if (window.poseEditorDebug.rect) console.log(`🔍 [calculateHandRect] 座標範囲詳細:`, {
+        xCoords: xCoords,
+        yCoords: yCoords,
+        xRange: `${Math.min(...xCoords).toFixed(2)} 〜 ${Math.max(...xCoords).toFixed(2)}`,
+        yRange: `${Math.min(...yCoords).toFixed(2)} 〜 ${Math.max(...yCoords).toFixed(2)}`,
+        xSpread: (Math.max(...xCoords) - Math.min(...xCoords)).toFixed(2),
+        ySpread: (Math.max(...yCoords) - Math.min(...yCoords)).toFixed(2)
+    });
+    
+    return rect;
 }
 
 // 🔧 顔キーポイントから矩形を計算（refs互換）
@@ -2685,6 +2888,13 @@ function calculateFaceRect(faceData, originalRes, scaleX, scaleY) {
 function drawEditableRect(ctx, rect, color, id) {
     if (!rect) return;
     
+    // 🔍 デバッグログ: 実際の描画座標
+    if (window.poseEditorDebug.rect) console.log(`🔍 [drawEditableRect] ${id} 描画座標:`, {
+        rect: { x: rect.x, y: rect.y, width: rect.width, height: rect.height },
+        color,
+        canvasTransform: ctx.getTransform()
+    });
+    
     // 太め破線で矩形描画（refs互換）
     ctx.strokeStyle = color;
     ctx.lineWidth = 3;
@@ -2885,12 +3095,21 @@ function updateRectControlDrag(mouseX, mouseY) {
     const controlPoint = window.poseEditorGlobals.draggedRectControl;
     const rectType = window.poseEditorGlobals.rectEditMode;
     
+    // 🔍 関数呼び出しログ
+    if (window.poseEditorDebug.rect) console.log(`🔍 [updateRectControlDrag] Called:`, {
+        rectType: rectType,
+        controlPoint: controlPoint,
+        mousePos: { x: mouseX, y: mouseY },
+        hasOriginalRect: !!window.poseEditorGlobals.originalRect
+    });
     
     if (!controlPoint) {
+        if (window.poseEditorDebug.rect) console.log(`⚠️ [updateRectControlDrag] No controlPoint, exiting`);
         return;
     }
     
     if (!rectType) {
+        if (window.poseEditorDebug.rect) console.log(`⚠️ [updateRectControlDrag] No rectType, exiting`);
         return;
     }
     
@@ -2960,9 +3179,24 @@ function updateRectControlDrag(mouseX, mouseY) {
     // 🔧 矩形を更新（累積変形防止のため直接設定）
     window.poseEditorGlobals.currentRects[rectType] = newRect;
     
+    // 🔍 矩形変換ログ
+    if (window.poseEditorDebug.rect) console.log(`🔍 [updateRectControlDrag] 矩形変換:`, {
+        rectType: rectType,
+        controlPosition: controlPoint.position,
+        originalRect: originalRect,
+        newRect: newRect,
+        mousePos: { x: mouseX, y: mouseY },
+        rectDelta: {
+            x: newRect.x - originalRect.x,
+            y: newRect.y - originalRect.y,
+            width: newRect.width - originalRect.width,
+            height: newRect.height - originalRect.height
+        }
+    });
     
     // 🔧 手・顔キーポイントの座標も更新（直接矩形変換版）
     if (controlPoint) {
+        if (window.poseEditorDebug.rect) console.log(`🔍 [updateRectControlDrag] Calling transformKeypointsDirectly...`);
         transformKeypointsDirectly(rectType, originalRect, newRect);
     }
     
@@ -3004,10 +3238,10 @@ function initializeRectEditInfo() {
         // 💥 ベースは初回のみ保存！編集済みデータで上書きしない
         if (!window.poseEditorGlobals.baseOriginalKeypoints) {
             window.poseEditorGlobals.baseOriginalKeypoints = JSON.parse(JSON.stringify(currentPoseData));
-            console.log('💖 [initializeRectEditInfo] Base original keypoints saved for FIRST editing session');
+            if (window.poseEditorDebug.rect) console.log('💖 [initializeRectEditInfo] Base original keypoints saved for FIRST editing session');
             
             // ベースデータの詳細確認
-            console.log('🔍 [initializeRectEditInfo] Base data details:', {
+            if (window.poseEditorDebug.rect) console.log('🔍 [initializeRectEditInfo] Base data details:', {
                 hasHandLeft: !!window.poseEditorGlobals.baseOriginalKeypoints.people?.[0]?.hand_left_keypoints_2d,
                 hasHandRight: !!window.poseEditorGlobals.baseOriginalKeypoints.people?.[0]?.hand_right_keypoints_2d,
                 hasFace: !!window.poseEditorGlobals.baseOriginalKeypoints.people?.[0]?.face_keypoints_2d,
@@ -3016,15 +3250,15 @@ function initializeRectEditInfo() {
                 faceLength: window.poseEditorGlobals.baseOriginalKeypoints.people?.[0]?.face_keypoints_2d?.length || 0
             });
         } else {
-            console.log('💖 [initializeRectEditInfo] Base original keypoints already exists - keeping original data');
+            if (window.poseEditorDebug.rect) console.log('💖 [initializeRectEditInfo] Base original keypoints already exists - keeping original data');
         }
         
         // 作業用は常にベースからコピー（編集済みデータではなく！）
         window.poseEditorGlobals.originalKeypoints = JSON.parse(JSON.stringify(window.poseEditorGlobals.baseOriginalKeypoints));
-        console.log('💖 [initializeRectEditInfo] Working original keypoints restored from base for current editing session');
+        if (window.poseEditorDebug.rect) console.log('💖 [initializeRectEditInfo] Working original keypoints restored from base for current editing session');
         
         // 作業用データの詳細確認
-        console.log('🔍 [initializeRectEditInfo] Working data details:', {
+        if (window.poseEditorDebug.rect) console.log('🔍 [initializeRectEditInfo] Working data details:', {
             hasHandLeft: !!window.poseEditorGlobals.originalKeypoints.people?.[0]?.hand_left_keypoints_2d,
             hasHandRight: !!window.poseEditorGlobals.originalKeypoints.people?.[0]?.hand_right_keypoints_2d,
             hasFace: !!window.poseEditorGlobals.originalKeypoints.people?.[0]?.face_keypoints_2d,
@@ -3577,4 +3811,4 @@ function drawEstimatedConnections(candidates, originalRes, scaleX, scaleY) {
     ctx.globalAlpha = 1.0;  // 不透明に戻す
 }
 
-// 🎨 pose_editor.js initialization complete
+// 🎨 pose_editor.js initialization complete