diff --git a/auto_tuner_guide.md b/auto_tuner_guide.md
new file mode 100644
index 0000000000..7e474dd5ef
--- /dev/null
+++ b/auto_tuner_guide.md
@@ -0,0 +1,63 @@
+# 🥕 CarrotPilot Auto-Tuner 사용 안내
+
+Auto-Tuner는 운전자의 실제 주행 패턴을 학습하여 오픈파일럿의 설정값을 **내 차와 내 운전 습관에 맞게 자동으로 최적화(튜닝)**해주는 스마트한 주행 보조 기능입니다.
+
+---
+
+## 📊 데이터 수집 및 적용 방식
+
+1. **주행 중 데이터 수집 (Learning)**
+   운전자가 오픈파일럿을 켠 상태로 주행할 때, 시스템은 백그라운드에서 차량의 속도, 가속도, 브레이크 타이밍, 조향 각도 등을 실시간으로 기록합니다. 특히 사용자가 답답함을 느껴 **가속 페달을 직접 밟거나(오버라이드)**, 불안해서 **직접 브레이크를 밟는 개입(Intervention)** 순간을 중점적으로 수집합니다.
+   
+2. **패턴 분석 (Analyzing)**
+   수집된 데이터를 바탕으로 현재 오픈파일럿 설정값이 운전자의 실제 주행 성향과 얼마나 차이나는지 분석하여 이상적인 파라미터 수치를 계산합니다.
+   
+3. **추천 및 적용 (Applying)**
+   주행을 마치고 **기어를 주차(P)로 변경**하면, 분석된 추천 설정값이 팝업으로 안내됩니다. 원하는 항목만 체크하여 **[선택 적용]**을 누르면 즉시 시스템에 반영됩니다. 적용된 내역은 설정 메뉴의 **[튜닝 이력]** 탭에서 언제든지 확인하고 관리할 수 있습니다.
+
+---
+
+## ⚙️ 그룹별 튜닝 설정 안내
+
+Auto-Tuner는 크게 다섯 가지 영역의 주행감을 학습하고 개선합니다.
+
+### 🚀 [가속] (Acceleration)
+오픈파일럿의 크루즈 가속 능력(속도 대역별 엑셀 밟는 양)을 조정합니다.
+운전자가 특정 속도 구간에서 직접 엑셀을 밟는 시간이 일정 기준(초)을 초과하면, 그 구간의 가속 한계치를 자동으로 올려줍니다.
+- **CruiseMaxVals0 [0~10km/h]**: 출발 및 극저속 구간의 가속력
+- **CruiseMaxVals1 [10~40km/h]**: 저속 시내 주행 구간의 가속력
+- **CruiseMaxVals2 [40~60km/h]**: 중속 구간의 가속력
+- **CruiseMaxVals3 [60~80km/h]**: 중고속 구간의 가속력
+- **CruiseMaxVals4 [80~100km/h]**: 고속 구간의 가속력
+- **CruiseMaxVals5 [100~130km/h]**: 초고속 구간의 가속력
+- **CruiseMaxVals6 [130km/h~]**: 최고속 구간의 가속력
+
+### 🚙 [주행] (Driving)
+선행 차량과의 간격 유지, 감속 타이밍 등 종방향(브레이크) 제어 능력을 조정합니다.
+운전자가 브레이크를 직접 밟아 개입(Intervention)하는 횟수가 누적되면, 시스템이 앞차와의 간격을 더 일찍 벌리거나 브레이크를 더 강하게 밟도록 유도합니다.
+- **JLeadFactor3 (감속 및 정지 제어)**: 앞차가 멈추거나 가까워질 때 브레이크를 밟는 타이밍과 강도를 결정합니다. 추천값을 적용하면 오픈파일럿이 조금 더 일찍, 부드럽게 감속을 시작하도록 튜닝되어 늦은 제동으로 인한 불안감을 해소합니다.
+
+### 🛣️ [거리] (Following Distance)
+고속도로 장거리 주행 시 선행 차량과의 추종 거리(TFollow)를 최적화합니다.
+운전자가 크루즈 인게이지 상태에서 선행차가 있음에도 가속 페달을 자주 밟는 패턴을 학습합니다. 이는 "시스템이 설정된 것보다 지나치게 거리를 넓게 벌려 주행하고 있어, 운전자가 능동적으로 간격을 좁히려 한다"는 신호로 해석합니다. 해당 GAP 단계의 TFollowGap 값을 자동으로 낮춰주어, 운전자가 원하는 더 촘촘한 간격으로 자연스럽게 추종하도록 개선합니다.
+- **TFollowGap1 (GAP1, 가장 좁음)**: 공격적 주행 스타일에 적합한 최소 추종 거리 (0.7s 이상)
+- **TFollowGap2 (GAP2)**: 일반 주행용 추종 거리
+- **TFollowGap3 (GAP3)**: 여유로운 추종 거리
+- **TFollowGap4 (GAP4, 가장 넓음)**: 장거리 고속 주행용 최대 추종 거리
+
+### 🎛️ [동적제어] (Dynamic Control)
+선행차 또는 내 차의 속도 변화에 따라 차간거리를 **동적으로** 조절하는 파라미터를 학습합니다.
+브레이크 관련 파라미터(JLeadFactor3 / DynamicTFollow / TFollowDecelBoost)가 동시에 여러 개 발동되면, 모두 "거리 확대" 방향이므로 합산 시 과보정 위험이 있습니다. 따라서 Auto-Tuner는 **이벤트가 가장 많은 1개만 먼저 추천**하고, 나머지는 다음 세션에서 재평가하도록 안내합니다.
+- **DynamicTFollow (앞차 급감속 반응 민감도)**: 앞차가 갑자기 감속할 때 차간거리를 얼마나 빠르게 넓힐지 결정합니다. 앞차의 급격한 속도 감소(jLead < -1.0) 중에 운전자가 직접 브레이크를 밟은 횟수가 쌓이면, 이 값을 높여 시스템이 앞차의 감속에 더 민감하게 반응하도록 합니다. (0이면 동적 조절 없음)
+- **TFollowDecelBoost (감속 중 추가 간격 확보)**: 내 차가 강하게 감속하는 상황에서 속도가 줄어들면 실제 거리 여유도 함께 줄어들게 됩니다. 강감속(a_ego < -0.8 m/s²) 중에 브레이크 개입이 반복되면 이 값을 높여, 감속이 강할수록 자동으로 더 넉넉한 간격을 유지하도록 보완합니다. (기본값 10, 범위 0~100)
+
+### 🔄 [조향] (Steering)
+직진 주행 시의 쏠림 현상과 곡선(커브) 도로에서의 핸들링 반응성을 조정합니다.
+- **PathOffset (직진 편차)**: 직선 도로를 달릴 때 운전자가 지속적으로 핸들을 미세하게 한쪽으로 당기고 있는 패턴을 분석합니다. 차가 미세하게 좌측이나 우측으로 쏠려서 주행한다고 판단되면 차선 내 중앙 위치(Offset)를 보정합니다.
+- **SteerActuatorDelay (조향 반응 지연)**: 커브 진입 시 오픈파일럿의 조향이 늦어 운전자가 핸들을 직접 꺾어(오버라이드) 궤적을 수정하는 패턴을 학습합니다. 잦은 오버라이드가 발생하면 액추에이터의 지연 시간(Delay) 변수를 늘려, 선행 조향각을 더 공격적으로 꺾어주어 빠르고 날카로운 코너링을 수행하도록 최적화합니다.
+- **SteerRatioRate (조향비율 배율)**: SteerActuatorDelay를 올려도 커브 추종이 개선되지 않고 오버라이드 빈도가 여전히 매우 높은 경우, 조향력 자체가 부족한 것으로 판단합니다. LiveParameters에서 측정된 실제 차량의 조향비(SR)에 추가로 배율을 곱해주어, 같은 핸들 각도에서 더 강하게 조향하도록 만들어 코너에서 차선 중앙 유지 능력을 개선합니다.
+
+---
+
+## ℹ️ 참고: 커브 구간 속도 제어
+커브 구간에서 고정된 속도 제한은 직선 주행에서는 답답하고, 급커브에서는 불안할 수 있습니다. CarrotPilot은 **오픈파일럿 모델이 예측하는 도로 곡률(Curvature)**을 실시간으로 읽어 커브의 강도에 따라 가속을 자동으로 제한하는 **동적 커브 속도 제어(Adaptive Curve Speed)** 기능을 별도 파라미터로 지원할 예정입니다. 이 기능은 Auto-Tuner와는 별개로 설정 메뉴의 크루즈/속도 탭에서 직접 조정할 수 있습니다.
diff --git a/common/params_keys.h b/common/params_keys.h
index 5b5e4a76a4..055de571d2 100644
--- a/common/params_keys.h
+++ b/common/params_keys.h
@@ -161,6 +161,12 @@ inline static std::unordered_map<std::string, ParamKeyAttributes> keys = {
     {"ShowPathColorLane", {PERSISTENT, INT, "13"}},
     {"ShowPlotMode", {PERSISTENT, INT, "0"}},
     {"CarrotTireTrajectory", {PERSISTENT, INT, "0"}},
+    {"CarrotLearningActive", {PERSISTENT, INT, "0"}},          // Auto-Tuner: 학습 활성화 (0=off, 1=on)
+    {"CarrotLearningData", {PERSISTENT, BYTES, ""}},           // Auto-Tuner: 누적 데이터 (JSON)
+    {"CarrotLearningRecommend", {PERSISTENT, BYTES, ""}},      // Auto-Tuner: 추천값 (JSON)
+    {"CarrotLearningPopupReady", {PERSISTENT, BOOL, "0"}},     // Auto-Tuner: 팝업 신호
+    {"CarrotLearningClear", {PERSISTENT, BOOL, "0"}},          // Auto-Tuner: 데이터 초기화 신호
+    {"CarrotLearningHistory", {PERSISTENT, BYTES, ""}},        // Auto-Tuner: 튜닝 이력 (JSON)
     {"RecordRoadCam", {PERSISTENT, INT, "0"}},
     {"HDPuse", {PERSISTENT, INT, "0"}},
 
diff --git a/karpathy.md b/karpathy.md
new file mode 100644
index 0000000000..c5fec7f502
--- /dev/null
+++ b/karpathy.md
@@ -0,0 +1,73 @@
+
+Behavioral guidelines to reduce common LLM coding mistakes. Merge with project-specific instructions as needed.
+
+**Tradeoff:** These guidelines bias toward caution over speed. For trivial tasks, use judgment.
+
+## 1. Think Before Coding
+
+**Don't assume. Don't hide confusion. Surface tradeoffs.**
+
+Before implementing:
+- State your assumptions explicitly. If uncertain, ask.
+- If multiple interpretations exist, present them - don't pick silently.
+- If a simpler approach exists, say so. Push back when warranted.
+- If something is unclear, stop. Name what's confusing. Ask.
+
+## 2. Simplicity First
+
+**Minimum code that solves the problem. Nothing speculative.**
+
+- No features beyond what was asked.
+- No abstractions for single-use code.
+- No "flexibility" or "configurability" that wasn't requested.
+- No error handling for impossible scenarios.
+- If you write 200 lines and it could be 50, rewrite it.
+
+Ask yourself: "Would a senior engineer say this is overcomplicated?" If yes, simplify.
+
+## 3. Surgical Changes
+
+**Touch only what you must. Clean up only your own mess.**
+
+When editing existing code:
+- Don't "improve" adjacent code, comments, or formatting.
+- Don't refactor things that aren't broken.
+- Match existing style, even if you'd do it differently.
+- If you notice unrelated dead code, mention it - don't delete it.
+
+When your changes create orphans:
+- Remove imports/variables/functions that YOUR changes made unused.
+- Don't remove pre-existing dead code unless asked.
+
+The test: Every changed line should trace directly to the user's request.
+
+## 4. Goal-Driven Execution
+
+**Define success criteria. Loop until verified.**
+
+Transform tasks into verifiable goals:
+- "Add validation" → "Write tests for invalid inputs, then make them pass"
+- "Fix the bug" → "Write a test that reproduces it, then make it pass"
+- "Refactor X" → "Ensure tests pass before and after"
+
+For multi-step tasks, state a brief plan:
+```
+1. [Step] → verify: [check]
+2. [Step] → verify: [check]
+3. [Step] → verify: [check]
+```
+
+Strong success criteria let you loop independently. Weak criteria ("make it work") require constant clarification.
+
+---
+
+**These guidelines are working if:** fewer unnecessary changes in diffs, fewer rewrites due to overcomplication, and clarifying questions come before implementation rather than after mistakes.
+
+## 5. Domain-Specific Verification (Openpilot / Cereal)
+
+**Never guess dynamic schemas. Verify against existing patterns.**
+
+When working with Openpilot's `cereal` (Cap'n Proto) framework or similar dynamic data structures:
+- **No Blind Imports:** Do not assume standard Python directory structures (e.g., `from cereal.car import CarState`). `cereal` generates objects dynamically from `.capnp` schemas.
+- **Cross-Reference Usage:** Before using a new attribute or enum (e.g., `GearShifter`), always `grep` or `view_file` existing Openpilot codebase to see exactly how it is imported and referenced (e.g., `from cereal import car` -> `car.CarState.GearShifter.park`).
+- **Assume Local Context Blindness:** Understand that local Mac environments often lack the `capnp` libraries or hardware dependencies required to test Openpilot code locally. Because local unit tests cannot catch `AttributeError` or `ModuleNotFoundError` for these hardware schemas, extreme caution and code-pattern matching must be used before committing.
diff --git a/selfdrive/carrot/carrot_functions.py b/selfdrive/carrot/carrot_functions.py
index 6de61ae8e3..8544efa20d 100644
--- a/selfdrive/carrot/carrot_functions.py
+++ b/selfdrive/carrot/carrot_functions.py
@@ -8,6 +8,7 @@
 from openpilot.common.conversions import Conversions as CV
 from openpilot.common.filter_simple import MyMovingAverage
 from openpilot.selfdrive.selfdrived.events import Events
+from openpilot.selfdrive.carrot.carrot_learning import CarrotLearner
 
 EventName = log.OnroadEvent.EventName
 LaneChangeState = log.LaneChangeState
@@ -139,6 +140,7 @@ def __init__(self):
 
     self._stop_x_rl = None
     self.last_event_time = 0.0
+    self.learner = CarrotLearner()
 
   def _params_update(self):
     self.frame += 1
@@ -628,6 +630,28 @@ def update(self, sm, v_cruise_kph, mode):
     self.mode = mode
     #return v_cruise, stop_dist, mode
 
+    # Auto-Tuner: 학습 데이터 수집
+    from cereal import car
+    gear_park = carstate.gearShifter == car.CarState.GearShifter.park
+    engaged = sm.alive.get('selfdriveState', False) and sm['selfdriveState'].enabled
+    
+    # 현재 GAP 단계 파악 (Personality 기반)
+    personality = sm['selfdriveState'].personality
+    current_gap = 2  # default standard
+    if personality == log.LongitudinalPersonality.moreRelaxed: current_gap = 4
+    elif personality == log.LongitudinalPersonality.relaxed: current_gap = 3
+    elif personality == log.LongitudinalPersonality.standard: current_gap = 2
+    elif personality == log.LongitudinalPersonality.aggressive: current_gap = 1
+    self.learner.set_current_gap(current_gap)
+
+    self.learner.update(v_ego_kph, carstate.gasPressed, engaged, gear_park,
+                        steer_deg=carstate.steeringAngleDeg, steer_pressed=carstate.steeringPressed,
+                        brake_pressed=carstate.brakePressed,
+                        lead_drel=leadOne.dRel if leadOne.status else 0.0,
+                        lead_v_kph=leadOne.vLead * CV.MS_TO_KPH if leadOne.status else 0.0,
+                        a_ego=a_ego, lead_jlead=leadOne.jLead if leadOne.status else 0.0,
+                        v_cruise_kph=v_cruise_kph)
+
     return v_cruise_kph
 
 class DrivingModeDetector:
diff --git a/selfdrive/carrot/carrot_learning.py b/selfdrive/carrot/carrot_learning.py
new file mode 100644
index 0000000000..f7a8b7b684
--- /dev/null
+++ b/selfdrive/carrot/carrot_learning.py
@@ -0,0 +1,593 @@
+"""
+CarrotLearning - Phase 1~4: Longitudinal + Lateral Learning
+karpathy.md 원칙 준수: 최소 구현, 단일 목적.
+
+[Phase 1] CruiseMaxVals0~6 (속도구간별 가속 강도)
+  트리거: 크루즈 인게이지 중 gasPressed
+  추천 발동: 구간당 누적 ≥ 10초
+
+[Phase 2] SteerActuatorDelay / PathOffset / SteerRatioRate (조향 딜레이 / 중심선 편차 / SR 비율)
+  트리거:
+    - 직진 시 steeringAngleDeg 편차 → PathOffset 추천
+    - 커브 진입 중 steeringPressed 비율 → SteerActuatorDelay 추천
+    - 커브 진입 중 steeringPressed 비율 (고비율) → SteerRatioRate 추천 (SR 부족 시)
+  추천 발동: 샘플 ≥ 200개 (약 20초 직진 데이터)
+
+[Phase 3] JLeadFactor3 (제동 반응성)
+  트리거: 선행차가 가깝고 느릴 때 brakePressed
+  추천 발동: 수동 제동 횟수 ≥ 5회
+
+[Phase 4] TFollowGap1~4 (차간 거리 설정)
+  트리거: 크루즈 인게이지 중 선행차 있음 + gasPressed
+         → 거리가 너무 넓어 운전자가 능동적으로 좁히려는 패턴
+  추천: 현재 GAP 단계의 TFollowGap 값 감소 추천 (거리 좁히기)
+  추천 발동: 인게이지 상태 선행차 추종 중 gas 개입 누적 ≥ 15초
+
+저장: Params("CarrotLearningData") — JSON 문자열
+팝업: gearShifter == park 시 CarrotLearningPopupReady = True
+"""
+
+import json
+import numpy as np
+from openpilot.common.params import Params
+from openpilot.common.conversions import Conversions as CV
+
+# ── Phase 1 상수 ─────────────────────────────────────────────────────
+_BP_KPH = [0, 10, 40, 60, 80, 110, 140]
+_NUM_BANDS = len(_BP_KPH)
+_ACCEL_KEYS = [f"CruiseMaxVals{i}" for i in range(_NUM_BANDS)]
+_GAS_THRESHOLD_SEC = 10.0       # 구간당 누적 개입 시간 기준 (초)
+_GAS_RECOMMEND_RATIO = 0.10     # 추천 증가 비율 (10%)
+_GAS_REDUCE_RATIO = -0.07       # 추천 감소 비율 (-7%, 가속 과다 시)
+_GAS_REDUCE_THRESHOLD_SEC = 5.0 # 가속 중 브레이크 개입 누적 기준 (초)
+
+# ── Phase 2 상수 ─────────────────────────────────────────────────────
+_STRAIGHT_DEG = 5.0             # 직진 판단 조향각 임계값 (도)
+_CURVE_RATE_DEG_S = 10.0        # 커브 진입 판단: 조향각 변화율 임계값 (도/초)
+_LATERAL_MIN_SAMPLES = 200      # PathOffset 추천을 위한 최소 직진 샘플 수
+_LATERAL_MIN_CURVE = 20         # SteerActuatorDelay 추천을 위한 최소 커브 이벤트 수
+_PATH_OFFSET_DEG_THRESHOLD = 1.5  # 평균 편차가 이 이상이면 PathOffset 추천 (도)
+_PATH_OFFSET_DEG_PER_UNIT = 0.1   # 1 도 편차 ≈ 10 units PathOffset 변화 (실험값)
+_CURVE_OVERRIDE_RATIO = 0.5     # 커브 진입의 50% 이상에서 override → SteerActuatorDelay 증가
+_DELAY_STEP_UNIT = 10           # SteerActuatorDelay 한 번 추천 시 변화량 (UI 단위, +0.1s)
+_SR_RATE_OVERRIDE_RATIO = 0.7   # 커브 진입의 70% 이상에서 override → SteerRatioRate 추가 추천
+_SR_RATE_STEP_UNIT = 3          # SteerRatioRate 한 번 추천 시 변화량 (+3%)
+
+# ── Phase 3 상수 ─────────────────────────────────────────────────────
+_BRAKE_MIN_COUNT = 5            # 추천을 위한 최소 수동 브레이크 횟수
+_JLEAD_STEP_UNIT = 10           # JLeadFactor3 한 번 추천 시 변화량
+_JLEAD_REDUCE_STEP = -7         # 제동 과다 시 변화량
+_JLEAD_GAS_THRESHOLD_SEC = 5.0  # 제동 중 가속 개입 누적 기준 (초)
+
+# ── Phase 5 상수 (DynamicTFollow / TFollowDecelBoost) ────────────────
+# DynamicTFollow: 앞차 급감속(jLead↓) 중 브레이크 개입 횟수 기반
+_DYN_TFOLLOW_BRAKE_MIN = 4      # 추천 발동 최소 이벤트 수
+_DYN_JLEAD_THRESHOLD = -1.0     # 앞차 가감속도 (m/s^3) 이하이면 '급감속' 판정
+_DYN_TFOLLOW_STEP = 5           # DynamicTFollow 한 번 추천 시 변화량 (+0.05)
+_DYN_TFOLLOW_MAX = 100          # 최대값 (=1.0)
+# TFollowDecelBoost: 내 차 감속 중 브레이크 개입 횟수 기반
+_DECEL_BOOST_BRAKE_MIN = 4      # 추천 발동 최소 이벤트 수
+_DECEL_A_THRESHOLD = -0.8       # 내 차 감속도 (m/s^2) 이하이면 '강한 감속' 판정
+_DECEL_BOOST_STEP = 5           # TFollowDecelBoost 한 번 추천 시 변화량 (+0.05)
+_DECEL_BOOST_MAX = 60           # 최대값
+
+# ── Phase 4 상수 ─────────────────────────────────────────────────────
+# TFollowGap1~4: Gap1(가장 좁음, 공격적), Gap4(가장 넓음, 여유)
+# 각 Gap에 해당하는 Params key
+_TFOLLOW_KEYS = ["TFollowGap1", "TFollowGap2", "TFollowGap3", "TFollowGap4"]
+_TFOLLOW_NAMES = ["GAP1", "GAP2", "GAP3", "GAP4"]
+_TFOLLOW_GAS_THRESHOLD_SEC = 15.0  # 선행차 추종 중 gas 누적 개입 시간 기준
+_TFOLLOW_STEP_UNIT = -5            # 감소 추천 (-5 units = -0.05s)
+_TFOLLOW_MIN_LEAD_DREL = 120.0     # 선행차 거리가 이보다 가까우면 '간격 좁히기' 패턴 아님
+_TFOLLOW_MIN_V_KPH = 60.0          # 고속도로 주행 구간에서만 학습
+_TFOLLOW_WIDEN_STEP = 5            # 증가 추천 (+0.05s)
+_TFOLLOW_BRAKE_THRESHOLD_SEC = 10.0 # 거리 부족으로 인한 브레이크 누적 기준 (초)
+_AUTO_HUNTING_THRESHOLD = 0.8      # 자율 주행 중 가감속 변동(Hunting) 감지 임계치 (m/s^2)
+
+# ── 공통 ─────────────────────────────────────────────────────────────
+_DT = 0.1  # update() 호출 주기 (초)
+
+
+def _speed_band(v_ego_kph: float) -> int:
+  """속도에 해당하는 가장 가까운 하위 구간 인덱스 반환"""
+  for i in range(_NUM_BANDS - 1, -1, -1):
+    if v_ego_kph >= _BP_KPH[i]:
+      return i
+  return 0
+
+
+class CarrotLearner:
+  """
+  CarrotPlanner.update()에서 매 프레임 호출됨.
+  Phase 1: 가속 개입 데이터 누적 → CruiseMaxVals 추천
+  Phase 2: 조향 편차/커브오버라이드 누적 → PathOffset / SteerActuatorDelay / SteerRatioRate 추천
+  Phase 3: 수동 제동 누적 → JLeadFactor3 추천
+  Phase 4: 선행차 추종 중 가속 개입 누적 → TFollowGap 감소 추천
+  Parking 전환 시 추천값을 Params에 기록.
+  """
+
+  def __init__(self):
+    self._params = Params()
+    # Phase 1
+    self._gas_acc = [0.0] * _NUM_BANDS
+    self._gas_dec_acc = [0.0] * _NUM_BANDS  # 가속 중 수동 브레이크 개입
+    self._gas_dec_auto_acc = [0.0] * _NUM_BANDS # 자율 주행 중 급가속 감지
+    # Phase 2
+    self._steer_acc = 0.0        # 직진 구간 조향각 누적합 (도)
+    self._steer_count = 0        # 직진 샘플 수
+    self._prev_steer_deg = 0.0   # 이전 프레임 조향각
+    self._curve_entries = 0      # 커브 진입 이벤트 수
+    self._curve_overrides = 0    # 커브 진입 중 steeringPressed 이벤트 수
+    self._in_curve_entry = False # 커브 진입 상태 플래그 (중복 카운트 방지)
+    # Phase 3
+    self._brake_count = 0        # 수동 브레이크 개입 횟수
+    self._brake_auto_count = 0   # 자율 주행 중 급제동 횟수
+    self._jlead_gas_acc = 0.0    # 제동 중 수동 가속 개입
+    self._prev_brake = False
+    # Phase 4 (TFollowGap)
+    self._tfollow_gas_acc = [0.0] * 4
+    self._tfollow_brake_acc = [0.0] * 4 # 수동 브레이크 개입
+    self._tfollow_brake_auto_acc = [0.0] * 4 # 자율 주행 중 헌팅 감지
+    self._current_gap = 1  # 현재 활성화된 GAP 단계 (1~4)
+    # Phase 5 (DynamicTFollow / TFollowDecelBoost)
+    self._dyn_brake_count = 0    # 앞차 급감속 중 브레이크 개입 횟수
+    self._decel_brake_count = 0  # 내 차 강한 감속 중 브레이크 개입 횟수
+
+    self._prev_gear_park = True  # 초기값(시동 시 P단 간주)
+    self._has_driven = False     # 주행(D단/이동) 여부 플래그
+    self._prev_a_ego = 0.0       # 이전 프레임 가속도
+    self._accel_swing_count = 0  # 가감속 반전(Hunting) 카운트
+
+    self._load()
+
+  # ------------------------------------------------------------------
+  # 공개 API
+  # ------------------------------------------------------------------
+
+  def set_current_gap(self, gap: int):
+    """현재 GAP 단계 설정 (1~4). CarrotPlanner에서 매 프레임 전달."""
+    self._current_gap = max(1, min(4, gap))
+
+  def update(self, v_ego_kph: float, gas_pressed: bool, engaged: bool, gear_park: bool,
+             steer_deg: float = 0.0, steer_pressed: bool = False,
+             brake_pressed: bool = False, lead_drel: float = 0.0, lead_v_kph: float = 0.0,
+             a_ego: float = 0.0, lead_jlead: float = 0.0, v_cruise_kph: float = 0.0):
+    """
+    매 프레임 호출.
+    - Phase 1: engaged + gas_pressed → 속도구간 누적
+    - Phase 2: engaged + 직진 → 조향 편차 누적
+               engaged + 커브 진입 + steer_pressed → override 카운트
+    - Phase 3: brake_pressed + 선행차 근접 → 브레이크 개입 카운트
+    - Phase 4: engaged + 선행차 존재 + gas_pressed + 고속 → TFollowGap gas 누적
+    - gear_park=True → 추천 계산 및 Params 저장
+    """
+    if not self._is_active():
+      return
+
+    # UI로부터 초기화(Clear) 신호가 오면 내부 메모리를 비움
+    if self._params.get_bool("CarrotLearningClear"):
+      self._clear_all_data()
+      self._params.put_bool("CarrotLearningClear", False)
+
+    # 주행 여부 판단 (인게이지 되거나 속도가 5km/h 이상이면 주행한 것으로 간주)
+    if engaged or v_ego_kph >= 5.0:
+      self._has_driven = True
+
+    # ── Phase 1: 가속 개입 ────────────────────────────────────────────
+    # 단순히 설정속도에 도달했는데 더 빨리 가고 싶어 밟는 경우는 제외 (설정속도 오버라이드)
+    # 즉, 설정속도보다 충분히 낮은데도 가속이 답답할 때만 학습에 포함
+    if engaged and gas_pressed and v_ego_kph >= 1.0:
+      if v_ego_kph < (v_cruise_kph - 3.0):
+        self._gas_acc[_speed_band(v_ego_kph)] += _DT
+    
+    # 가속 과다 학습 방지: 가속 중인데 브레이크를 밟는 경우 OR 자율 주행 중 과도한 가속
+    if engaged and v_ego_kph < (v_cruise_kph - 3.0):
+      idx = _speed_band(v_ego_kph)
+      if brake_pressed:
+        if lead_drel == 0 or lead_drel > 120.0:
+          self._gas_dec_acc[idx] += _DT
+      elif not gas_pressed and a_ego > 1.5: # 자율 주행 중 급가속 감지
+        self._gas_dec_acc[idx] += _DT * 0.5
+
+    # ── Phase 2: 조향 패턴 (속도 20km/h 이상, 인게이지 상태) ──────────
+    if engaged and v_ego_kph >= 20.0:
+      steer_rate = abs(steer_deg - self._prev_steer_deg) / _DT
+
+      # 직진 구간 편차 수집 (override 없을 때만 순수 자동조향 편차)
+      if abs(steer_deg) < _STRAIGHT_DEG and not steer_pressed:
+        self._steer_acc += steer_deg
+        self._steer_count += 1
+
+      # 커브 진입 감지 (조향각 변화율이 임계값 초과)
+      if steer_rate > _CURVE_RATE_DEG_S:
+        if not self._in_curve_entry:
+          self._curve_entries += 1
+          if steer_pressed:
+            self._curve_overrides += 1
+          self._in_curve_entry = True
+      else:
+        self._in_curve_entry = False
+
+    self._prev_steer_deg = steer_deg
+
+    # Phase 3: 수동 제동 (선행차 근접 시) ────────────────────────
+    if engaged and not gear_park and 0 < lead_drel < 100.0:
+      # (1) 수동 제동 트리거
+      if brake_pressed and not self._prev_brake:
+        self._brake_count += 1
+      # (2) 자율 주행 중 너무 늦게 급제동 발생 -> 제동 시점 앞당기기 필요
+      elif not brake_pressed and a_ego < -1.7:
+        self._brake_count += 0.3
+    
+    # 제동 과다 학습 방지: 강한 제동 중 가속 페달을 밟는 경우 (불필요한 제동 억제)
+    if engaged and gas_pressed and a_ego < -0.8:
+      if 0 < lead_drel < 150.0:
+        self._jlead_gas_acc += _DT
+
+    # ── Phase 5: DynamicTFollow / TFollowDecelBoost ──────────────────
+    if brake_pressed and not self._prev_brake:
+      # DynamicTFollow: 앞차 급감속 중 브레이크 개입
+      if lead_jlead < _DYN_JLEAD_THRESHOLD and lead_drel < 150.0:
+        self._dyn_brake_count += 1
+      # TFollowDecelBoost: 내 차 강한 감속 중 브레이크 개입
+      if a_ego < _DECEL_A_THRESHOLD:
+        self._decel_brake_count += 1
+
+    self._prev_brake = brake_pressed
+
+    # ── Phase 4: TFollowGap (선행차 추종 중 가속 개입) ──────────────
+    # 고속 크루즈 중 선행차가 충분히 멀리 있는데도 gas를 밟는다면
+    # → 시스템이 설정된 거리보다 넓게 벌어져 있어 운전자가 좁히려는 것
+    if (engaged and gas_pressed and v_ego_kph >= _TFOLLOW_MIN_V_KPH
+        and lead_drel > _TFOLLOW_MIN_LEAD_DREL):
+      gap_idx = self._current_gap - 1  # 0-indexed
+      self._tfollow_gas_acc[gap_idx] += _DT
+
+    # 거리 부족 학습 방지: 정속 추종 중 불안해서 브레이크를 밟는 경우 OR Hunting 감지
+    if engaged and v_ego_kph >= 40.0 and 0 < lead_drel < 80.0:
+      gap_idx = self._current_gap - 1
+      if brake_pressed:
+        if abs(v_ego_kph - lead_v_kph) < 5.0:
+          self._tfollow_brake_acc[gap_idx] += _DT
+      else:
+        # 자율 주행 중 가감속 헌팅(Swing) 감지
+        if (self._prev_a_ego > 0.3 and a_ego < -0.3) or (self._prev_a_ego < -0.3 and a_ego > 0.3):
+          self._accel_swing_count += 1
+          if self._accel_swing_count > 8:
+            self._tfollow_brake_acc[gap_idx] += _DT * 0.2
+            self._accel_swing_count = 0
+
+    # 주차 감지 (이전에 주차가 아니었고, 주행을 한 번이라도 한 경우에만 발동)
+    if gear_park and not self._prev_gear_park and self._has_driven:
+      self._on_parking()
+      self._has_driven = False  # 팝업 후 플래그 초기화
+
+    self._prev_gear_park = gear_park
+
+  def _clear_all_data(self):
+    """모든 누적 데이터를 0으로 초기화하고 DB에서도 삭제"""
+    self._gas_acc = [0.0] * _NUM_BANDS
+    self._steer_acc = 0.0
+    self._steer_count = 0
+    self._curve_entries = 0
+    self._curve_overrides = 0
+    self._brake_count = 0
+    self._tfollow_gas_acc = [0.0] * 4
+    self._dyn_brake_count = 0
+    self._decel_brake_count = 0
+    self._params.remove("CarrotLearningData")
+    self._params.remove("CarrotLearningRecommend")
+
+  def is_active(self) -> bool:
+    return self._is_active()
+
+  # ------------------------------------------------------------------
+  # 내부 메서드
+  # ------------------------------------------------------------------
+
+  def _is_active(self) -> bool:
+    return self._params.get_int("CarrotLearningActive") == 1
+
+  def _load(self):
+    """이전 세션 누적 데이터 복원"""
+    raw = self._params.get("CarrotLearningData")
+    if not raw:
+      return
+    try:
+      data = json.loads(raw)
+      # Phase 1
+      loaded = data.get("gas_acc", [0.0] * _NUM_BANDS)
+      if len(loaded) == _NUM_BANDS:
+        self._gas_acc = [float(x) for x in loaded]
+      loaded_dec = data.get("gas_dec_acc", [0.0] * _NUM_BANDS)
+      if len(loaded_dec) == _NUM_BANDS:
+        self._gas_dec_acc = [float(x) for x in loaded_dec]
+      loaded_auto = data.get("gas_dec_auto_acc", [0.0] * _NUM_BANDS)
+      if len(loaded_auto) == _NUM_BANDS:
+        self._gas_dec_auto_acc = [float(x) for x in loaded_auto]
+      # Phase 2
+      lat = data.get("lateral", {})
+      self._steer_acc = float(lat.get("steer_acc", 0.0))
+      self._steer_count = int(lat.get("steer_count", 0))
+      self._curve_entries = int(lat.get("curve_entries", 0))
+      self._curve_overrides = int(lat.get("curve_overrides", 0))
+      # Phase 3
+      lon = data.get("lon", {})
+      self._brake_count = int(lon.get("brake_count", 0))
+      self._jlead_gas_acc = float(lon.get("jlead_gas_acc", 0.0))
+      # Phase 4
+      loaded4 = data.get("tfollow_gas_acc", [0.0] * 4)
+      if len(loaded4) == 4:
+        self._tfollow_gas_acc = [float(x) for x in loaded4]
+      loaded4_dec = data.get("tfollow_brake_acc", [0.0] * 4)
+      if len(loaded4_dec) == 4:
+        self._tfollow_brake_acc = [float(x) for x in loaded4_dec]
+      loaded4_auto = data.get("tfollow_brake_auto_acc", [0.0] * 4)
+      if len(loaded4_auto) == 4:
+        self._tfollow_brake_auto_acc = [float(x) for x in loaded4_auto]
+      # Phase 5
+      p5 = data.get("phase5", {})
+      self._dyn_brake_count = int(p5.get("dyn_brake_count", 0))
+      self._decel_brake_count = int(p5.get("decel_brake_count", 0))
+    except Exception:
+      pass  # 데이터 손상 시 기본값 유지
+
+  def _save(self):
+    """현재 누적 데이터를 Params에 저장"""
+    data = {
+      "gas_acc": self._gas_acc,
+      "gas_dec_acc": self._gas_dec_acc,
+      "lateral": {
+        "steer_acc": self._steer_acc,
+        "steer_count": self._steer_count,
+        "curve_entries": self._curve_entries,
+        "curve_overrides": self._curve_overrides,
+      },
+      "lon": {
+        "brake_count": self._brake_count,
+        "jlead_gas_acc": self._jlead_gas_acc,
+      },
+      "tfollow_gas_acc": self._tfollow_gas_acc,
+      "tfollow_brake_acc": self._tfollow_brake_acc,
+      "tfollow_brake_auto_acc": self._tfollow_brake_auto_acc,
+      "gas_dec_auto_acc": self._gas_dec_auto_acc,
+      "phase5": {
+        "dyn_brake_count": self._dyn_brake_count,
+        "decel_brake_count": self._decel_brake_count,
+      },
+    }
+    self._params.put("CarrotLearningData", json.dumps(data).encode('utf8'))
+
+  def _on_parking(self):
+    """주차 전환 시: 저장 → 추천 계산 → 팝업 신호"""
+    self._save()
+    recommendations = self._calc_recommendations()
+    if not recommendations:
+      return
+    self._params.put("CarrotLearningRecommend", json.dumps(recommendations).encode('utf8'))
+    self._params.put_bool("CarrotLearningPopupReady", True)
+
+  def _calc_recommendations(self) -> dict:
+    """Phase 1~4 추천값 계산. 추천 없으면 빈 dict 반환."""
+    result = {
+      "가속 (Acceleration)": {},
+      "조향 (Steering)": {},
+      "주행 (Driving)": {},
+      "거리 (Following Distance)": {},
+      "동적제어 (Dynamic Control)": {},
+    }
+
+    # ── Phase 1: CruiseMaxVals ──────────────────────────────────────
+    for i, acc_sec in enumerate(self._gas_acc):
+      key = _ACCEL_KEYS[i]
+      current_raw = self._params.get_int(key)
+      if current_raw <= 0: continue
+
+      total_dec = self._gas_dec_acc[i] + self._gas_dec_auto_acc[i]
+      if acc_sec >= _GAS_THRESHOLD_SEC:
+        recommended_raw = min(250, int(current_raw * (1.0 + _GAS_RECOMMEND_RATIO)))
+        reason = "gas help (manual)"
+        sec = acc_sec
+      elif total_dec >= _GAS_REDUCE_THRESHOLD_SEC:
+        recommended_raw = max(50, int(current_raw * (1.0 + _GAS_REDUCE_RATIO)))
+        reason = "aggressive accel (auto)" if self._gas_dec_auto_acc[i] > self._gas_dec_acc[i] else "too aggressive (manual)"
+        sec = total_dec
+      else:
+        continue
+
+      if recommended_raw != current_raw:
+        result["가속 (Acceleration)"][key] = {
+          "current": current_raw,
+          "recommended": recommended_raw,
+          "band_kph": f"{_BP_KPH[i]}~{_BP_KPH[i+1] if i+1 < _NUM_BANDS else '∞'} km/h ({reason})",
+          "acc_sec": round(sec, 1),
+        }
+
+    # ── Phase 2a: PathOffset (직진 편차) ────────────────────────────
+    if self._steer_count >= _LATERAL_MIN_SAMPLES:
+      avg_deg = self._steer_acc / self._steer_count
+      if abs(avg_deg) >= _PATH_OFFSET_DEG_THRESHOLD:
+        current_offset = self._params.get_int("PathOffset")
+        # 양수 avg_deg: 차가 우측으로 쏠림 → PathOffset 증가 (경로를 우측으로)
+        delta = int(avg_deg / _PATH_OFFSET_DEG_PER_UNIT)
+        recommended = int(np.clip(current_offset + delta, -200, 200))
+        if recommended != current_offset:
+          result["조향 (Steering)"]["PathOffset"] = {
+            "current": current_offset,
+            "recommended": recommended,
+            "band_kph": "straight driving",
+            "avg_deg": round(avg_deg, 2),
+          }
+
+    # ── Phase 2b: SteerActuatorDelay (커브 진입 override 비율) ──────
+    if self._curve_entries >= _LATERAL_MIN_CURVE:
+      override_ratio = self._curve_overrides / self._curve_entries
+      if override_ratio >= _CURVE_OVERRIDE_RATIO:
+        current_delay = self._params.get_int("SteerActuatorDelay")
+        recommended = min(300, current_delay + _DELAY_STEP_UNIT)
+        if recommended != current_delay:
+          result["조향 (Steering)"]["SteerActuatorDelay"] = {
+            "current": current_delay,
+            "recommended": recommended,
+            "band_kph": "curve entry",
+            "override_ratio": round(override_ratio * 100, 1),
+          }
+
+      # ── Phase 2c: SteerRatioRate (커브 override 비율이 매우 높을 때) ─
+      # SteerActuatorDelay 증가로도 부족한 경우, SteerRatioRate(SR 배율)를 추가로 높임
+      if override_ratio >= _SR_RATE_OVERRIDE_RATIO:
+        current_sr_rate = self._params.get_int("SteerRatioRate")
+        if current_sr_rate <= 0:
+          current_sr_rate = 100  # 기본값 100%
+        recommended_sr = min(150, current_sr_rate + _SR_RATE_STEP_UNIT)
+        if recommended_sr != current_sr_rate:
+          result["조향 (Steering)"]["SteerRatioRate"] = {
+            "current": current_sr_rate,
+            "recommended": recommended_sr,
+            "band_kph": "curve entry (high override)",
+            "override_ratio": round(override_ratio * 100, 1),
+          }
+
+    # ── Phase 3: JLeadFactor3 (수동 제동) ───────────────────────────
+    jlead_candidate = None
+    total_brake = self._brake_count + self._brake_auto_count
+    if total_brake >= _BRAKE_MIN_COUNT:
+      current_jlead = self._params.get_int("JLeadFactor3")
+      recommended = min(200, current_jlead + _JLEAD_STEP_UNIT)
+      if recommended != current_jlead:
+        reason = "late braking (auto)" if self._brake_auto_count > self._brake_count else "approaching lead (manual)"
+        jlead_candidate = {
+          "current": current_jlead,
+          "recommended": recommended,
+          "band_kph": f"{reason}",
+          "brake_count": round(total_brake, 1),
+          "_signal": total_brake,
+        }
+    elif self._jlead_gas_acc >= _JLEAD_GAS_THRESHOLD_SEC:
+      current_jlead = self._params.get_int("JLeadFactor3")
+      recommended = max(50, current_jlead + _JLEAD_REDUCE_STEP)
+      if recommended != current_jlead:
+        jlead_candidate = {
+          "current": current_jlead,
+          "recommended": recommended,
+          "band_kph": "too aggressive (gas override)",
+          "gas_sec": round(self._jlead_gas_acc, 1),
+          "_signal": self._jlead_gas_acc,
+        }
+
+    # ── Phase 4: TFollowGap (선행차 추종 중 거리 좁히기 가속 개입) ──
+    for i, gas_sec in enumerate(self._tfollow_gas_acc):
+      key = _TFOLLOW_KEYS[i]
+      name = _TFOLLOW_NAMES[i]
+      current_val = self._params.get_int(key)
+      if current_val <= 0: continue
+
+      total_dec = self._tfollow_brake_acc[i] + self._tfollow_brake_auto_acc[i]
+      if gas_sec >= _TFOLLOW_GAS_THRESHOLD_SEC:
+        recommended_val = max(70, current_val + _TFOLLOW_STEP_UNIT)
+        reason = "too wide (manual gas)"
+        sec = gas_sec
+      elif total_dec >= _TFOLLOW_BRAKE_THRESHOLD_SEC:
+        recommended_val = min(200, current_val + _TFOLLOW_WIDEN_STEP)
+        reason = "hunting detected (auto)" if self._tfollow_brake_auto_acc[i] > self._tfollow_brake_acc[i] else "too short (manual brake)"
+        sec = total_dec
+      else:
+        continue
+
+      if recommended_val != current_val:
+        result["거리 (Following Distance)"][key] = {
+          "current": current_val,
+          "recommended": recommended_val,
+          "band_kph": f"highway ≥{_TFOLLOW_MIN_V_KPH:.0f}km/h ({name}, {reason})",
+          "sec": round(sec, 1),
+        }
+
+    # ── Phase 5a: DynamicTFollow (앞차 급감속 반응 민감도) ───────────
+    dyn_candidate = None
+    if self._dyn_brake_count >= _DYN_TFOLLOW_BRAKE_MIN:
+      current_dyn = self._params.get_int("DynamicTFollow")
+      recommended_dyn = min(_DYN_TFOLLOW_MAX, current_dyn + _DYN_TFOLLOW_STEP)
+      if recommended_dyn != current_dyn:
+        dyn_candidate = {
+          "current": current_dyn,
+          "recommended": recommended_dyn,
+          "band_kph": "lead decel override",
+          "brake_count": self._dyn_brake_count,
+          "_signal": self._dyn_brake_count,
+        }
+
+    # ── Phase 5b: TFollowDecelBoost (내 차 감속 중 버퍼 확보) ────────
+    boost_candidate = None
+    if self._decel_brake_count >= _DECEL_BOOST_BRAKE_MIN:
+      current_boost = self._params.get_int("TFollowDecelBoost")
+      recommended_boost = min(_DECEL_BOOST_MAX, current_boost + _DECEL_BOOST_STEP)
+      if recommended_boost != current_boost:
+        boost_candidate = {
+          "current": current_boost,
+          "recommended": recommended_boost,
+          "band_kph": "decel braking",
+          "brake_count": self._decel_brake_count,
+          "_signal": self._decel_brake_count,
+        }
+
+    # ── 브레이크 파라미터 충돌 방지: 동시 다중 적용 시 과보정 억제 ──
+    # JLeadFactor3 / DynamicTFollow / TFollowDecelBoost 는 모두
+    # '제동 여유 확대' 방향이므로 동시 적용 시 복합 효과로 과보수화 위험.
+    # → 가장 강한 시그널 1개만 이번 세션에 추천하고, 나머지는 '다음 세션' 권고.
+    brake_candidates = [
+      ("JLeadFactor3",      "주행 (Driving)",         jlead_candidate),
+      ("DynamicTFollow",    "동적제어 (Dynamic Control)", dyn_candidate),
+      ("TFollowDecelBoost", "동적제어 (Dynamic Control)", boost_candidate),
+    ]
+    active = [(name, group, c) for name, group, c in brake_candidates if c is not None]
+
+    if len(active) <= 1:
+      # 충돌 없음: 그냥 모두 추가
+      for name, group, c in active:
+        entry = {k: v for k, v in c.items() if k != "_signal"}
+        result[group][name] = entry
+    else:
+      # 2개 이상 동시 발동 → 시그널이 가장 강한 것 1개만 추천
+      active_sorted = sorted(active, key=lambda x: x[2]["_signal"], reverse=True)
+      winner_name, winner_group, winner_c = active_sorted[0]
+      entry = {k: v for k, v in winner_c.items() if k != "_signal"}
+      # 다음 세션에 재평가하도록 안내 메시지 추가
+      deferred_names = [n for n, g, c in active_sorted[1:]]
+      entry["band_kph"] = entry["band_kph"] + f" ※다음세션권고:{','.join(deferred_names)}"
+      result[winner_group][winner_name] = entry
+
+    return {k: v for k, v in result.items() if v}
+
+  def apply_recommendations(self):
+    """UI [적용] 버튼 클릭 시 호출. 추천 적용 + 데이터 초기화."""
+    raw = self._params.get("CarrotLearningRecommend")
+    if not raw:
+      return
+    try:
+      recommendations = json.loads(raw)
+    except Exception:
+      return
+    for group in recommendations:
+      for key in recommendations[group]:
+        info = recommendations[group][key]
+        self._params.put_int(key, info["recommended"])
+
+    # 데이터 초기화
+    self._gas_acc = [0.0] * _NUM_BANDS
+    self._gas_dec_acc = [0.0] * _NUM_BANDS
+    self._gas_dec_auto_acc = [0.0] * _NUM_BANDS
+    self._steer_acc = 0.0
+    self._steer_count = 0
+    self._curve_entries = 0
+    self._curve_overrides = 0
+    self._brake_count = 0
+    self._brake_auto_count = 0
+    self._jlead_gas_acc = 0.0
+    self._tfollow_gas_acc = [0.0] * 4
+    self._tfollow_brake_acc = [0.0] * 4
+    self._tfollow_brake_auto_acc = [0.0] * 4
+    self._dyn_brake_count = 0
+    self._decel_brake_count = 0
+    self._params.remove("CarrotLearningData")
+    self._params.remove("CarrotLearningRecommend")
+    self._params.put_bool("CarrotLearningPopupReady", False)
diff --git a/selfdrive/carrot_settings.json b/selfdrive/carrot_settings.json
index 5185d611e8..0def5d48d2 100644
--- a/selfdrive/carrot_settings.json
+++ b/selfdrive/carrot_settings.json
@@ -1473,6 +1473,22 @@
       "ctitle": "显示路线信息",
       "cdescr": "仅在连接 APN 时运行。0: 关闭, 1: 开启"
     },
+    {
+      "group": "화면패스",
+      "name": "CarrotLearningActive",
+      "title": "Auto-Tuner: 학습(0)",
+      "descr": "주행 중 운전자 개입(가속/제동) 데이터를 학습하여 파라미터 최적화를 추천합니다.\n 0: 끄기\n 1: 켜기",
+      "egroup": "DISP",
+      "etitle": "Auto-Tuner: Learning",
+      "edescr": "Learns from driver interventions (gas/brake) to recommend parameter adjustments.\n 0: Off, 1: On",
+      "min": 0,
+      "max": 1,
+      "default": 0,
+      "unit": 1,
+      "cgroup": "显示设置",
+      "ctitle": "自动调整器: 学习",
+      "cdescr": "从驾驶员干预中学习以推荐参数调整。0: 关闭, 1: 开启"
+    },
     {
       "group": "화면패스",
       "name": "CarrotTireTrajectory",
diff --git a/selfdrive/ui/qt/home.cc b/selfdrive/ui/qt/home.cc
index f027f477a6..c38e7d1ff5 100644
--- a/selfdrive/ui/qt/home.cc
+++ b/selfdrive/ui/qt/home.cc
@@ -4,10 +4,300 @@
 #include <QMouseEvent>
 #include <QStackedWidget>
 #include <QVBoxLayout>
+#include <QJsonDocument>
+#include <QJsonObject>
 
 #include "selfdrive/ui/qt/offroad/experimental_mode.h"
 #include "selfdrive/ui/qt/util.h"
 #include "selfdrive/ui/qt/widgets/prime.h"
+#include "selfdrive/ui/qt/widgets/input.h"
+#include "common/params.h"
+#include <QScrollArea>
+#include <QScroller>
+#include <QDialogButtonBox>
+#include <QCheckBox>
+#include <QMap>
+#include <QDateTime>
+#include <QDialogButtonBox>
+#include <QScrollArea>
+#include <QScroller>
+#include "selfdrive/ui/qt/qt_window.h"
+#include "selfdrive/ui/qt/widgets/input.h"
+
+class AutoTunerGuideDialog : public DialogBase {
+public:
+  explicit AutoTunerGuideDialog(const QString &html_content, QWidget *parent = nullptr) : DialogBase(parent) {
+    setWindowFlags(Qt::Popup | Qt::FramelessWindowHint);
+    setAttribute(Qt::WA_TranslucentBackground);
+    setStyleSheet(R"(
+      DialogBase { background: transparent; }
+      #container { background-color: #1b1b1b; border-radius: 20px; }
+      QLabel { color: #dddddd; font-size: 45px; margin: 20px; }
+      QPushButton { padding: 20px; height: 100px; font-size: 45px; border-radius: 10px; color: white; background-color: #465BEA; }
+      QPushButton:pressed { background-color: #3049F4; }
+    )");
+
+    QVBoxLayout *outer_layout = new QVBoxLayout(this);
+    outer_layout->setContentsMargins(40, 40, 40, 40); // Maximize layout
+
+    QFrame *container = new QFrame(this);
+    container->setObjectName("container");
+    QVBoxLayout *main_layout = new QVBoxLayout(container);
+    main_layout->setContentsMargins(20, 20, 20, 20);
+
+    QLabel *text = new QLabel(html_content);
+    text->setWordWrap(true);
+    text->setAlignment(Qt::AlignTop | Qt::AlignLeft);
+    
+    QScrollArea *scroll = new QScrollArea();
+    scroll->setWidgetResizable(true);
+    scroll->setFrameShape(QFrame::NoFrame);
+    scroll->setStyleSheet("QScrollArea { background: transparent; } QWidget { background: transparent; }");
+    QScroller::grabGesture(scroll->viewport(), QScroller::LeftMouseButtonGesture);
+    scroll->setWidget(text);
+
+    main_layout->addWidget(scroll, 1);
+
+    QPushButton *btn_ok = new QPushButton(tr("확인"));
+    btn_ok->setFixedWidth(400);
+    main_layout->addWidget(btn_ok, 0, Qt::AlignCenter);
+
+    outer_layout->addWidget(container);
+
+    connect(btn_ok, &QPushButton::clicked, this, &QDialog::accept);
+  }
+
+  void showEvent(QShowEvent *event) override {
+    setMainWindow(this);
+    QDialog::showEvent(event);
+  }
+};
+
+class AutoTunerDialog : public DialogBase {
+public:
+  QMap<QString, QCheckBox*> item_checkboxes;
+  QJsonObject recommendations;
+
+  explicit AutoTunerDialog(const QString &title_text, const QJsonObject &recs, QWidget *parent = nullptr) : DialogBase(parent), recommendations(recs) {
+    setWindowFlags(Qt::Popup | Qt::FramelessWindowHint);
+    setAttribute(Qt::WA_TranslucentBackground);
+    setStyleSheet(R"(
+      DialogBase { background: transparent; }
+      #container { background-color: #2b2b2b; border-radius: 30px; border: 2px solid #555555; }
+      QLabel { color: white; }
+      QCheckBox { font-size: 45px; color: white; spacing: 20px; }
+      QCheckBox::indicator { width: 50px; height: 50px; }
+      QPushButton { padding: 25px; font-size: 45px; font-weight: 500; border-radius: 10px; color: white; background-color: #444444; }
+      QPushButton:pressed { background-color: #333333; }
+    )");
+
+    QVBoxLayout *outer_layout = new QVBoxLayout(this);
+    outer_layout->setContentsMargins(200, 40, 200, 40); // Maximize vertically, slightly wider horizontally
+
+    QFrame *container = new QFrame(this);
+    container->setObjectName("container");
+    QVBoxLayout *main_layout = new QVBoxLayout(container);
+    main_layout->setContentsMargins(40, 30, 40, 30);
+    main_layout->setSpacing(15);
+
+    QLabel *title = new QLabel(title_text);
+    title->setStyleSheet("font-size: 55px; font-weight: bold; margin-bottom: 10px;");
+    title->setAlignment(Qt::AlignCenter);
+    main_layout->addWidget(title);
+
+    QScrollArea *scroll = new QScrollArea();
+    scroll->setWidgetResizable(true);
+    scroll->setFrameShape(QFrame::NoFrame);
+    scroll->setStyleSheet("QScrollArea { background: transparent; } QWidget { background: transparent; }");
+    QScroller::grabGesture(scroll->viewport(), QScroller::LeftMouseButtonGesture);
+    
+    QWidget *scroll_widget = new QWidget();
+    QVBoxLayout *scroll_layout = new QVBoxLayout(scroll_widget);
+    scroll_layout->setContentsMargins(0, 0, 0, 0);
+    scroll_layout->setSpacing(15);
+
+    for (const QString& group : recommendations.keys()) {
+      QJsonObject group_items = recommendations[group].toObject();
+      
+      QString short_group;
+      bool is_en = (QString::fromStdString(Params().get("LanguageSetting")) != "main_ko");
+      if (is_en && group.contains("(")) {
+        short_group = group.split("(").last().replace(")", "");
+      } else {
+        short_group = group.split(" ").first();
+      }
+
+      for (const QString& key : group_items.keys()) {
+        QJsonObject info = group_items[key].toObject();
+        QString item_text = QString("<span style='color:#aaaaaa;'>[%1]</span> <b>%2</b> <span style='font-size:40px; color:#bbbbbb;'>[%3]</span> &nbsp;:&nbsp; %4 ➔ <span style='color:#00ff00; font-weight:bold;'>%5</span>")
+                                    .arg(short_group)
+                                    .arg(key)
+                                    .arg(info["band_kph"].toString())
+                                    .arg(info["current"].toInt())
+                                    .arg(info["recommended"].toInt());
+        
+        QCheckBox *cb = new QCheckBox();
+        cb->setText(item_text);
+        // Qt uses rich text in QCheckBox only if we set it this way or implicitly, but since Qt 5.11 text formats are auto-detected.
+        // If rich text doesn't render in QCheckBox text, we will use a QLabel alongside a checkbox.
+        // Wait, QCheckBox text does not support rich text by default natively in all styles.
+        // Let's create a horizontal layout for each item: Checkbox + QLabel
+        
+        QHBoxLayout *item_layout = new QHBoxLayout();
+        item_layout->setContentsMargins(0, 0, 0, 15);
+        item_layout->setSpacing(20);
+        
+        QCheckBox *item_cb = new QCheckBox();
+        item_cb->setChecked(true);
+        item_cb->setStyleSheet("QCheckBox::indicator { width: 50px; height: 50px; }");
+        
+        QLabel *item_label = new QLabel(item_text);
+        item_label->setStyleSheet("font-size: 45px; color: white;");
+        item_label->setWordWrap(true);
+        
+        item_layout->addWidget(item_cb);
+        item_layout->addWidget(item_label, 1);
+        
+        scroll_layout->addLayout(item_layout);
+        item_checkboxes[key] = item_cb;
+      }
+    }
+    scroll_layout->addStretch();
+    scroll->setWidget(scroll_widget);
+    main_layout->addWidget(scroll, 1);
+
+    QHBoxLayout *btn_layout = new QHBoxLayout();
+    
+    QPushButton *btn_guide = new QPushButton(tr("사용 안내 (Guide)"));
+    btn_guide->setStyleSheet("background-color: #3b5998;");
+    
+    QPushButton *btn_later = new QPushButton(tr("나중에 (Later)"));
+    btn_later->setStyleSheet("background-color: #555555;");
+    
+    QPushButton *btn_clear = new QPushButton(tr("학습 초기화 (Clear)"));
+    btn_clear->setStyleSheet("background-color: #8a1d1d;");
+    
+    QPushButton *btn_apply = new QPushButton(tr("선택 적용 (Apply Selected)"));
+    btn_apply->setStyleSheet("background-color: #178644;");
+
+    btn_layout->addWidget(btn_guide);
+    btn_layout->addWidget(btn_later);
+    btn_layout->addWidget(btn_clear);
+    btn_layout->addWidget(btn_apply);
+    main_layout->addLayout(btn_layout);
+
+    outer_layout->addWidget(container);
+
+    connect(btn_guide, &QPushButton::clicked, this, [=]() {
+      QString guide_html;
+      if (QString::fromStdString(Params().get("LanguageSetting")) != "main_ko") {
+        guide_html = R"(
+        <div style='font-size: 45px;'>
+        <div style='text-align:center; font-size: 55px; font-weight: bold; margin-bottom: 20px;'>🥕 CarrotPilot Auto-Tuner Guide</div><hr>
+        <div style='font-size: 50px; font-weight: bold; margin-top: 20px; margin-bottom: 10px;'>📊 Data Collection &amp; Application</div>
+        <ul>
+        <li><b>Data Collection</b>: Records driving data in the background, focusing on <b>overrides (gas pedal)</b> and <b>interventions (brake pedal)</b>.</li>
+        <li><b>Pattern Analysis</b>: Analyzes the gap between current settings and driving behavior to calculate ideal parameters.</li>
+        <li><b>Recommendation &amp; Apply</b>: Shows a popup when parking (P). Click <b>[Apply Selected]</b> to apply. (Manage in <b>Tuning History</b>)</li>
+        </ul><hr>
+        <div style='font-size: 50px; font-weight: bold; margin-top: 20px; margin-bottom: 10px;'>⚙️ Group Parameter Details</div>
+        <b>🚀 [Acceleration]</b><br>
+        Adjusts cruise control acceleration capabilities.<br>
+        - <b>CruiseMaxVals0~6</b>: Increases accel limits per speed band to fix sluggish starts and acceleration.<br>
+        <b>🚙 [Driving]</b><br>
+        Adjusts longitudinal (brake) control.<br>
+        - <b>JLeadFactor3</b>: If the driver brakes frequently, it tunes the system to start braking earlier and smoother.<br>
+        <b>🛣️ [Following Distance]</b><br>
+        Optimizes highway following distance. If gas is pressed often while following a lead car at speed, it means the gap is too wide. Recommends decreasing TFollowGap for that gap level.<br>
+        - <b>TFollowGap1~4</b>: Per-GAP-level time-gap setting (seconds x100). Lower = closer.<br>
+        <b>🎛️ [Dynamic Control]</b><br>
+        If multiple brake params trigger at once, only the strongest signal is recommended this session to avoid over-correction. Others deferred to next session.<br>
+        - <b>DynamicTFollow</b>: When lead car decelerates suddenly, driver may brake to compensate. More events = system widens gap faster when lead decelerates. (0=off)<br>
+        - <b>TFollowDecelBoost</b>: During strong ego deceleration, gap shrinks naturally. More events = system maintains extra buffer during braking. (default 10, range 0~100)<br>
+        <b>🔄 [Steering]</b><br>
+        Adjusts handling responsiveness.<br>
+        - <b>PathOffset</b>: Compensates for lane drifts.<br>
+        - <b>SteerActuatorDelay</b>: Reduces cornering delay.<br>
+        <hr>
+        <div style='font-size: 50px; font-weight: bold; margin-top: 20px; margin-bottom: 10px;'>🧠 Autonomous Pattern Detection</div>
+        Even without your pedal input, the system monitors its own control quality:<br>
+        - <b>(auto) Late Braking</b>: If the system brakes too hard at the last moment, it recommends increasing JLeadFactor3 to start braking earlier.<br>
+        - <b>(auto) Aggressive Accel</b>: If the system accelerates too harshly relative to the lead car, it recommends lowering CruiseMaxVals.<br>
+        - <b>(auto) Hunting</b>: If the system oscillates between accel/decel while following, it recommends widening the gap for stability.
+        </div>
+        )";
+      } else {
+        guide_html = R"(
+        <div style='font-size: 45px;'>
+        <div style='text-align:center; font-size: 55px; font-weight: bold; margin-bottom: 20px;'>🥕 CarrotPilot Auto-Tuner 사용 안내</div><hr>
+        <div style='font-size: 50px; font-weight: bold; margin-top: 20px; margin-bottom: 10px;'>📊 데이터 수집 및 적용 방식</div>
+        <ul>
+        <li><b>주행 중 데이터 수집</b>: 백그라운드에서 차량의 주행 데이터를 실시간으로 기록하며, 특히 <b>오버라이드(가속 페달 밟음)</b>와 <b>개입(직접 브레이크)</b> 순간을 중점 수집합니다.</li>
+        <li><b>패턴 분석</b>: 현재 설정값과 운전자 주행 성향의 차이를 분석하여 이상적인 파라미터를 계산합니다.</li>
+        <li><b>추천 및 적용</b>: 주차(P) 시 팝업으로 추천값을 안내하며, <b>[선택 적용]</b>을 누르면 즉시 반영됩니다. (설정의 <b>튜닝 이력</b>에서 이력 확인/삭제 가능)</li>
+        </ul><hr>
+        <div style='font-size: 50px; font-weight: bold; margin-top: 20px; margin-bottom: 10px;'>⚙️ 그룹별 튜닝 설정 안내</div>
+        <b>🚀 [가속] (Acceleration)</b><br>
+        오픈파일럿의 크루즈 가속 능력을 조정합니다.<br>
+        - <b>CruiseMaxVals0~6</b>: 속도 대역별 가속 한계치를 높여 굼뜬 출발과 답답한 가속을 개선합니다.<br>
+        <b>🚙 [주행] (Driving)</b><br>
+        종방향(브레이크) 제어 능력을 조정합니다.<br>
+        - <b>JLeadFactor3</b>: 운전자가 브레이크를 자주 밟을 경우, 앞차가 가까워질 때 조금 더 일찍 감속을 시작하도록 유도합니다.<br>
+        <b>🛣️ [거리] (Following Distance)</b><br>
+        고속도 주행 중 선행차 추종 거리를 최적화합니다. 선행차가 있는데도 가속 페달을 자주 밟는다면, 시스템이 지나치게 거리를 넓게 유지하는 것으로 판단하여 해당 GAP의 TFollowGap 값을 줄이는 방향으로 추천합니다.<br>
+        - <b>TFollowGap1~4</b>: GAP 단계별 추종 거리 시간(x0.01초). 낙을수록 가깄워집니다. 최소 0.70초 보장.<br>
+        <b>🎛️ [동적제어] (Dynamic Control)</b><br>
+        브레이크 관련 파라미터가 동시 여러 개 발동되면 합산 과보정 위험이 있어, 이벤트가 가장 많은 1개만 먼저 추천합니다. 나머지는 다음 세션 재평가.<br>
+        - <b>DynamicTFollow</b>: 앞차가 급감속할 때 브레이크 개입이 쌓이면, 시스템이 앞차 감속에 더 빠르게 반응하도록 조정합니다. (0=사용 안 함)<br>
+        - <b>TFollowDecelBoost</b>: 내 차 강감속 중 브레이크 개입이 쌓이면, 감속이 강할수록 자동으로 더 넉넉한 간격을 유지하도록 보완합니다. (기본값 10, 범위 0~100)<br>
+        <b>🔄 [조향] (Steering)</b><br>
+        핸들링 반응성을 조정합니다.<br>
+        - <b>PathOffset / SteerActuatorDelay</b>: 조향 편차 및 지연 보정.<br>
+        <hr>
+        <div style='font-size: 50px; font-weight: bold; margin-top: 20px; margin-bottom: 10px;'>🧠 자율 주행 패턴 자동 감지</div>
+        운전자가 페달을 밟지 않아도, 시스템은 스스로의 제어 품질을 감시합니다:<br>
+        - <b>(auto) 늦은 제동</b>: 시스템이 뒤늦게 급제동을 거는 패턴이 감지되면, 더 일찍 부드럽게 감속하도록 제동 시점 상향을 추천합니다.<br>
+        - <b>(auto) 과도한 가속</b>: 선행차 흐름에 비해 시스템이 너무 거칠게 가속하면, 가속 한계치를 낮추도록 추천합니다.<br>
+        - <b>(auto) 주행 요동(Hunting)</b>: 가속과 감속을 반복하며 거리를 불안정하게 맞추는 패턴이 감지되면, 제어의 여유를 위해 차간 거리를 넓히도록 추천합니다.
+        </div>
+        )";
+      }
+      AutoTunerGuideDialog *d = new AutoTunerGuideDialog(guide_html, this);
+      d->exec();
+      d->deleteLater();
+    });
+
+    connect(btn_later, &QPushButton::clicked, this, &QDialog::reject);
+    
+    connect(btn_clear, &QPushButton::clicked, [=]() {
+      if (ConfirmationDialog::confirm(tr("적용하지 않고 현재까지의 모든 학습 데이터를 삭제하시겠습니까?"), tr("초기화"), this)) {
+        Params().putBool("CarrotLearningClear", true);
+        this->reject();
+      }
+    });
+
+    connect(btn_apply, &QPushButton::clicked, this, &QDialog::accept);
+  }
+
+  QJsonObject getSelectedItems() {
+    QJsonObject selected;
+    for (const QString& group : recommendations.keys()) {
+      QJsonObject group_items = recommendations[group].toObject();
+      QJsonObject selected_group_items;
+      
+      for (const QString& key : group_items.keys()) {
+        if (item_checkboxes.contains(key) && item_checkboxes[key]->isChecked()) {
+          selected_group_items[key] = group_items[key];
+        }
+      }
+      
+      if (!selected_group_items.isEmpty()) {
+        selected[group] = selected_group_items;
+      }
+    }
+    return selected;
+  }
+};
 
 #ifdef ENABLE_MAPS
 #include "selfdrive/ui/qt/maps/map_settings.h"
@@ -80,6 +370,66 @@ void HomeWindow::updateState(const UIState &s) {
       break;
   }
 
+  // Auto-Tuner: 주행 중 주차(P단) 전환 시 즉시 팝업 표시 (1초 주기로 체크)
+  static int carrot_tuner_frame = 0;
+  if (carrot_tuner_frame++ % 20 == 0) {
+    Params params;
+    if (params.getBool("CarrotLearningPopupReady")) {
+      // 중복 팝업 방지를 위해 즉시 플래그 해제
+      params.putBool("CarrotLearningPopupReady", false);
+      
+      QString raw = QString::fromStdString(params.get("CarrotLearningRecommend"));
+      QJsonDocument doc = QJsonDocument::fromJson(raw.toUtf8());
+      if (!raw.isEmpty() && doc.isObject()) {
+        QJsonObject obj = doc.object();
+        QString msg = tr("Auto-Tuner: Driving pattern learned!");
+        
+        AutoTunerDialog *dialog = new AutoTunerDialog(msg, obj, this);
+        connect(dialog, &QDialog::accepted, [=]() {
+          Params p;
+          QJsonObject selected = dialog->getSelectedItems();
+          if (!selected.isEmpty()) {
+            QJsonArray history_array;
+            QString history_raw = QString::fromStdString(p.get("CarrotLearningHistory"));
+            if (!history_raw.isEmpty()) {
+              QJsonDocument h_doc = QJsonDocument::fromJson(history_raw.toUtf8());
+              if (h_doc.isArray()) history_array = h_doc.array();
+            }
+
+            QJsonObject history_entry;
+            history_entry["timestamp"] = QDateTime::currentDateTime().toString("yyyy-MM-dd HH:mm");
+            history_entry["changes"] = selected;
+            history_entry["id"] = QString::number(QDateTime::currentMSecsSinceEpoch());
+            
+            history_array.prepend(history_entry);
+            while (history_array.size() > 50) history_array.removeLast();
+
+            p.put("CarrotLearningHistory", QJsonDocument(history_array).toJson(QJsonDocument::Compact).toStdString());
+
+            for (const QString& group : selected.keys()) {
+              QJsonObject group_items = selected[group].toObject();
+              for (const QString& key : group_items.keys()) {
+                QJsonObject info = group_items[key].toObject();
+                int recommended = info["recommended"].toInt(0);
+                if (recommended > 0) {
+                  p.put(key.toStdString(), std::to_string(recommended));
+                }
+              }
+            }
+          }
+          Params().putBool("CarrotLearningClear", true);
+          dialog->deleteLater();
+        });
+        
+        connect(dialog, &QDialog::rejected, [=]() {
+          dialog->deleteLater();
+        });
+
+        setMainWindow(dialog);
+      }
+    }
+  }
+
 }
 
 void HomeWindow::offroadTransition(bool offroad) {
@@ -87,9 +437,10 @@ void HomeWindow::offroadTransition(bool offroad) {
   sidebar->setVisible(offroad);
   UIState* s = uiState();
   if (offroad) {
-    
+
     s->scene._current_carrot_display = 1;
     slayout->setCurrentWidget(home);
+
   } else {
     slayout->setCurrentWidget(onroad);
 
diff --git a/selfdrive/ui/qt/offroad/settings.cc b/selfdrive/ui/qt/offroad/settings.cc
index 3af6f16b59..ee6e0015c8 100644
--- a/selfdrive/ui/qt/offroad/settings.cc
+++ b/selfdrive/ui/qt/offroad/settings.cc
@@ -7,6 +7,11 @@
 
 #include <QDebug>
 #include <QProcess>
+#include <QScrollArea>
+#include <QScroller>
+#include <QJsonArray>
+#include <QJsonDocument>
+#include <QJsonObject>
 
 #include "common/watchdog.h"
 #include "common/util.h"
@@ -460,6 +465,180 @@ void SettingsWindow::setCurrentPanel(int index, const QString &param) {
   nav_btns->buttons()[index]->setChecked(true);
 }
 
+AutoTunerHistoryPanel::AutoTunerHistoryPanel(QWidget* parent) : QFrame(parent) {
+  QVBoxLayout *main_layout = new QVBoxLayout(this);
+  main_layout->setContentsMargins(50, 50, 50, 50);
+
+  QLabel *title = new QLabel(tr("Auto-Tuner History Log v2"));
+  title->setStyleSheet("font-size: 60px; font-weight: bold; margin-bottom: 20px; color: white;");
+  main_layout->addWidget(title);
+
+  QPushButton *btn_clear = new QPushButton(tr("전체 이력 삭제 (Clear All)"));
+  btn_clear->setStyleSheet("background-color: #bb3333; font-size: 45px; padding: 30px; border-radius: 10px; margin-bottom: 30px; color: white; font-weight: bold;");
+  connect(btn_clear, &QPushButton::clicked, this, &AutoTunerHistoryPanel::clearAll);
+  main_layout->addWidget(btn_clear);
+
+  QScrollArea *scroll = new QScrollArea();
+  scroll->setWidgetResizable(true);
+  scroll->setFrameShape(QFrame::NoFrame);
+  scroll->setStyleSheet("QScrollArea { background: transparent; } QWidget { background: transparent; }");
+  QScroller::grabGesture(scroll->viewport(), QScroller::LeftMouseButtonGesture);
+
+  QWidget *scroll_widget = new QWidget();
+  list_layout = new QVBoxLayout(scroll_widget);
+  list_layout->setSpacing(30);
+  
+  scroll->setWidget(scroll_widget);
+  main_layout->addWidget(scroll);
+
+  refreshHistory();
+}
+
+void AutoTunerHistoryPanel::showEvent(QShowEvent *event) {
+  refreshHistory();
+  QFrame::showEvent(event);
+}
+
+void AutoTunerHistoryPanel::refreshHistory() {
+  QLayoutItem *child;
+  while ((child = list_layout->takeAt(0)) != nullptr) {
+    if (child->widget()) delete child->widget();
+    delete child;
+  }
+
+  QString raw = QString::fromStdString(Params().get("CarrotLearningHistory"));
+  if (raw.isEmpty()) {
+    QLabel *empty = new QLabel(tr("이력이 없습니다. (No tuning history available)"));
+    empty->setStyleSheet("font-size: 45px; color: #888888;");
+    list_layout->addWidget(empty);
+    list_layout->addStretch();
+    return;
+  }
+
+  QJsonArray arr = QJsonDocument::fromJson(raw.toUtf8()).array();
+  for (int i = 0; i < arr.size(); i++) {
+    QJsonObject item = arr[i].toObject();
+    QString id = item["id"].toString();
+    QString time_str = item["timestamp"].toString();
+    QJsonObject changes = item["changes"].toObject();
+
+    QFrame *row = new QFrame();
+    row->setStyleSheet("background-color: #333333; border-radius: 15px; padding: 20px;");
+    QHBoxLayout *row_layout = new QHBoxLayout(row);
+
+    QString text = QString("<span style='font-size: 35px; color: #aaaaaa;'>[%1 적용됨]</span><br>").arg(time_str);
+    for (const QString& group : changes.keys()) {
+      QJsonObject g_items = changes[group].toObject();
+      QString short_group;
+      bool is_en = (QString::fromStdString(Params().get("LanguageSetting")) != "main_ko");
+      if (is_en && group.contains("(")) {
+        short_group = group.split("(").last().replace(")", "");
+      } else {
+        short_group = group.split(" ").first(); // e.g. "가속"
+      }
+      for (const QString& key : g_items.keys()) {
+        QJsonObject info = g_items[key].toObject();
+        text += QString("<span style='font-size: 40px; color: white;'><span style='color:#aaaaaa;'>[%1]</span> <b>%2</b> <span style='font-size:35px; color:#bbbbbb;'>[%3]</span> &nbsp;:&nbsp; %4 ➔ <span style='color:#00ff00; font-weight:bold;'>%5</span></span><br>")
+                  .arg(short_group)
+                  .arg(key)
+                  .arg(info["band_kph"].toString())
+                  .arg(info["current"].toInt())
+                  .arg(info["recommended"].toInt());
+      }
+    }
+
+    QLabel *lbl = new QLabel(text);
+    lbl->setWordWrap(true);
+    row_layout->addWidget(lbl, 1);
+
+    bool is_latest = (i == 0);
+    
+    QPushButton *btn_restore = new QPushButton(tr("복구"));
+    if (is_latest) {
+      btn_restore->setStyleSheet("background-color: #178644; font-size: 40px; padding: 20px; border-radius: 10px; color: white;");
+    } else {
+      btn_restore->setStyleSheet("background-color: #333333; font-size: 40px; padding: 20px; border-radius: 10px; color: #666666;");
+      btn_restore->setEnabled(false);
+    }
+    btn_restore->setFixedSize(200, 120);
+    connect(btn_restore, &QPushButton::clicked, [this, id]() { restoreItem(id); });
+    row_layout->addWidget(btn_restore);
+
+    QPushButton *btn_del = new QPushButton(tr("삭제"));
+    if (is_latest) {
+      btn_del->setStyleSheet("background-color: #555555; font-size: 40px; padding: 20px; border-radius: 10px; color: white;");
+    } else {
+      btn_del->setStyleSheet("background-color: #333333; font-size: 40px; padding: 20px; border-radius: 10px; color: #666666;");
+      btn_del->setEnabled(false);
+    }
+    btn_del->setFixedSize(200, 120);
+    connect(btn_del, &QPushButton::clicked, [this, id]() { deleteItem(id); });
+    row_layout->addWidget(btn_del);
+
+    list_layout->addWidget(row);
+  }
+  list_layout->addStretch();
+}
+
+void AutoTunerHistoryPanel::restoreItem(const QString& id) {
+  if (ConfirmationDialog::confirm(tr("이 시점의 튜닝을 취소하고 모든 값을 이전 상태로 되돌리시겠습니까?"), tr("복구"), this)) {
+    QString raw = QString::fromStdString(Params().get("CarrotLearningHistory"));
+    QJsonArray arr = QJsonDocument::fromJson(raw.toUtf8()).array();
+    QJsonArray new_arr;
+    
+    for (int i = 0; i < arr.size(); i++) {
+      QJsonObject entry = arr[i].toObject();
+      if (entry["id"].toString() == id) {
+        // 복구 로직: 이력에 저장된 'current' 값을 다시 Params에 기록
+        QJsonObject changes = entry["changes"].toObject();
+        for (const QString& group : changes.keys()) {
+          QJsonObject g_items = changes[group].toObject();
+          for (const QString& key : g_items.keys()) {
+            int prev_val = g_items[key].toObject()["current"].toInt();
+            Params().putInt(key.toStdString(), prev_val);
+          }
+        }
+      } else {
+        new_arr.append(entry);
+      }
+    }
+    
+    if (new_arr.isEmpty()) {
+      Params().remove("CarrotLearningHistory");
+    } else {
+      Params().put("CarrotLearningHistory", QJsonDocument(new_arr).toJson(QJsonDocument::Compact).toStdString());
+    }
+    refreshHistory();
+    ConfirmationDialog::alert(tr("이전 값으로 복구가 완료되었습니다."), this);
+  }
+}
+
+void AutoTunerHistoryPanel::deleteItem(const QString& id) {
+  if (ConfirmationDialog::confirm(tr("정말 이 항목을 삭제하시겠습니까?"), tr("삭제"), this)) {
+    QString raw = QString::fromStdString(Params().get("CarrotLearningHistory"));
+    QJsonArray arr = QJsonDocument::fromJson(raw.toUtf8()).array();
+    QJsonArray new_arr;
+    for (int i = 0; i < arr.size(); i++) {
+      if (arr[i].toObject()["id"].toString() != id) {
+        new_arr.append(arr[i]);
+      }
+    }
+    if (new_arr.isEmpty()) {
+      Params().remove("CarrotLearningHistory");
+    } else {
+      Params().put("CarrotLearningHistory", QJsonDocument(new_arr).toJson(QJsonDocument::Compact).toStdString());
+    }
+    refreshHistory();
+  }
+}
+
+void AutoTunerHistoryPanel::clearAll() {
+  if (ConfirmationDialog::confirm(tr("모든 이력을 삭제하시겠습니까? (이전 파라미터 값으로 되돌아가지 않습니다)"), tr("전체 삭제"), this)) {
+    Params().remove("CarrotLearningHistory");
+    refreshHistory();
+  }
+}
+
 SettingsWindow::SettingsWindow(QWidget *parent) : QFrame(parent) {
 
   // setup two main layouts
@@ -509,6 +688,7 @@ SettingsWindow::SettingsWindow(QWidget *parent) : QFrame(parent) {
     panels.append({tr("Firehose"), new FirehosePanel(this)});
   }
   panels.append({ tr("CarrotPilot"), new CarrotPanel(this) });
+  panels.append({ tr("튜닝 이력"), new AutoTunerHistoryPanel(this) });
   panels.append({ tr("Developer"), new DeveloperPanel(this) });
 
   nav_btns = new QButtonGroup(this);
@@ -692,6 +872,7 @@ CarrotPanel::CarrotPanel(QWidget* parent) : QWidget(parent) {
   //cruiseToggles->addItem(new CValueControl("MyHighModeFactor", "DRIVEMODE: HIGH ratio(100%)", "AccelRatio control ratio", 100, 300, 10));
 
   latLongToggles = new ListWidget(this);
+  latLongToggles->addItem(new CValueControl("CarrotLearningActive", tr("Auto-Tuner: Learning"), tr("Learn from driver interventions (gas/brake) and recommend parameter adjustments when parking. 0=Off, 1=On"), 0, 1, 1));
   latLongToggles->addItem(new CValueControl("UseLaneLineSpeed", tr("Laneline mode speed(0)"), tr("Laneline mode, lat_mpc control used"), 0, 200, 5));
   latLongToggles->addItem(new CValueControl("UseLaneLineCurveSpeed", tr("Laneline mode curve speed(0)"), tr("Laneline mode, high speed only"), 0, 200, 5));
   latLongToggles->addItem(new CValueControl("AdjustLaneOffset", tr("AdjustLaneOffset(0)cm"), "", 0, 500, 5));
diff --git a/selfdrive/ui/qt/offroad/settings.h b/selfdrive/ui/qt/offroad/settings.h
index dd60ede091..cab002a001 100644
--- a/selfdrive/ui/qt/offroad/settings.h
+++ b/selfdrive/ui/qt/offroad/settings.h
@@ -153,3 +153,18 @@ private slots:
   int m_max;
   int m_unit;
 };
+
+class AutoTunerHistoryPanel : public QFrame {
+  Q_OBJECT
+public:
+  explicit AutoTunerHistoryPanel(QWidget* parent = nullptr);
+private slots:
+  void refreshHistory();
+  void deleteItem(const QString& id);
+  void restoreItem(const QString& id);
+  void clearAll();
+private:
+  QVBoxLayout *list_layout;
+protected:
+  void showEvent(QShowEvent *event) override;
+};