Sync DemoService aa0ec3b35f9dd33dbf0d56e23f5af0ad1cac70f4

api/ai-service/app/api/v1/endpoints/route_generation.py

@@ -51,6 +51,7 @@ class RouteGenerateRequest(BaseModel):
     selectedLabel: str | None = None
     selectedTopK: int = Field(default=0, ge=0, le=20)
     fastRoads: bool = True
+    autoDistance: bool = False
     generationId: str | None = Field(default=None, max_length=200)
     # The route-search page knows the centre of every selectable region.  Keep
     # it as a recovery coordinate so a temporary geocoder failure never turns
@@ -402,6 +403,7 @@ def _run_fast_road_pipeline(
     route_count: int,
     target_distance_km: float,
     selected_label: str | None,
+    auto_distance: bool = False,
 ) -> dict[str, Any]:
     """Create real walkable-road routes without per-route CLIP inference.
 
@@ -425,12 +427,17 @@ def _run_fast_road_pipeline(
     # failed request before it can return any usable road loop.
     examples = getattr(module, "GPX_SHAPE_TEMPLATES", {}).get(selected_label, [])
     candidate_pool = min(16 if examples else 8, max(route_count, route_count + (11 if examples else 1)))
-    candidates = build_candidates(
+    candidate_options = dict(
         graph=graph,
         route_count=candidate_pool,
         target_distance_m=target_distance_km * 1000.0,
         selected_label=selected_label,
     )
+    if auto_distance:
+        candidate_options["auto_distance"] = True
+    candidates = build_candidates(**candidate_options)
+    if auto_distance and selected_label:
+        candidates = [route for route in candidates if route.get("generation_mode") == "label_guided"]
     # A selected shape is a preference, not a reason to leave the runner with
     # no route.  Sparse neighbourhoods and long distances do not always have
     # enough roads to satisfy the strict shape-quality gate.  In that case
@@ -438,7 +445,7 @@ def _run_fast_road_pipeline(
     # the response marks them as non-art-ready so the UI can state this
     # honestly instead of showing a red generation failure.
     generation_mode = "fast_walk_roads"
-    if not candidates and selected_label:
+    if not candidates and selected_label and not auto_distance:
         candidates = build_candidates(
             graph=graph,
             route_count=candidate_pool,
@@ -447,7 +454,7 @@ def _run_fast_road_pipeline(
             tolerance_ratio=0.60,
         )
         generation_mode = "fast_walk_roads_nearby_fallback"
-    if not candidates:
+    if not candidates and not auto_distance:
         # Rural/island road graphs may have no acceptable drawing or loop.
         # A return trip along existing walking edges is still a real route.
         candidates = _nearby_road_return_routes(
@@ -502,6 +509,9 @@ def _run_fast_road_pipeline(
             abs(route["length_km"] - target_distance_km),
         ))
         routes = routes[:route_count]
+    elif auto_distance:
+        routes.sort(key=lambda route: -route["top1_score"])
+        routes = routes[:route_count]
     if not routes:
         raise RuntimeError("Walkable road routes did not contain usable map coordinates.")
 
@@ -511,7 +521,8 @@ def _run_fast_road_pipeline(
         "candidate_count": len(candidates),
         "requested_count": route_count,
         "generated_count": len(routes),
-        "target_distance_km": target_distance_km,
+        "target_distance_km": routes[0]["length_km"] if auto_distance else target_distance_km,
+        "auto_distance": auto_distance,
         "radius_km": radius_km,
         "labels": [selected_label] if selected_label else [],
         "selected_label": selected_label,
@@ -673,12 +684,12 @@ def generate_routes(payload: RouteGenerateRequest) -> dict[str, Any]:
 
     route_count_cap = 20 if use_current else 100
     route_count = min(route_count_cap, max(1, payload.routeCount))
-    target_distance_km = max(0.5, payload.targetDistanceKm)
+    target_distance_km = 6.0 if payload.autoDistance else max(0.5, payload.targetDistanceKm)
     # A 1.5 km graph is enough for ordinary short courses, but it cannot make
     # a truthful 16~30 km route.  Grow the road graph only as much as the
     # requested distance needs, up to the request model's safe 10 km limit.
     required_radius_km = target_distance_km / 5.5
-    radius_km = min(10.0, max(1.5, min(10.0, payload.radiusKm), required_radius_km))
+    radius_km = min(10.0, max(5.0 if payload.autoDistance else 1.5, min(10.0, payload.radiusKm), required_radius_km))
 
     if payload.fastRoads:
         module = None
@@ -693,6 +704,7 @@ def generate_routes(payload: RouteGenerateRequest) -> dict[str, Any]:
                 route_count=route_count,
                 target_distance_km=target_distance_km,
                 selected_label=selected_label,
+                auto_distance=payload.autoDistance,
             )
         except Exception as primary_exc:
             logger.exception("fast walk-road route generation failed")
@@ -722,22 +734,36 @@ def generate_routes(payload: RouteGenerateRequest) -> dict[str, Any]:
                             route_count=route_count,
                             target_distance_km=target_distance_km,
                             selected_label=selected_label,
+                            auto_distance=payload.autoDistance,
                         )
                     except Exception:
                         logger.exception("fallback-centre walk-road generation failed")
                 # Provider outages must reach this branch too. Previously the
                 # early skip above also skipped recovery and returned HTTP 503.
                 template_fn = getattr(module, "guided_waypoints_for_label", None)
+                guided_template = template_fn(selected_label) if callable(template_fn) else None
+                gpx_templates = getattr(module, "GPX_SHAPE_TEMPLATES", {}).get(selected_label, [])
+                if payload.autoDistance and selected_label and not guided_template and not gpx_templates:
+                    raise HTTPException(
+                        status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
+                        detail="선택한 모양의 경로 데이터를 불러오지 못했습니다. 잠시 후 다시 시도해주세요.",
+                    )
                 real_roads = generate_walking_fallback(
                     center_lat=fallback_lat, center_lon=fallback_lon,
                     route_count=route_count, target_distance_km=target_distance_km,
                     selected_label=selected_label, place=payload.place,
-                    template=template_fn(selected_label) if callable(template_fn) else None,
-                    templates=getattr(module, "GPX_SHAPE_TEMPLATES", {}).get(selected_label, []),
+                    template=guided_template,
+                    templates=gpx_templates,
                     generation_id=payload.generationId,
+                    auto_distance=payload.autoDistance,
                 )
                 if real_roads:
                     return real_roads
+                if payload.autoDistance:
+                    raise HTTPException(
+                        status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
+                        detail="선택한 지역에서 해당 모양에 가까운 실제 보행 경로를 찾지 못했습니다. 다시 찾기를 눌러주세요.",
+                    )
                 return _coordinate_fallback_routes(
                     center_lat=fallback_lat,
                     center_lon=fallback_lon,

api/ai-service/app/services/walking_route_fallback.py

@@ -80,8 +80,9 @@ def generate_walking_fallback(
     template: list[tuple[float, float]] | None = None,
     templates: list[list[tuple[float, float]]] | None = None,
     generation_id: str | None = None,
+    auto_distance: bool = False,
 ) -> dict[str, Any] | None:
-    key = (round(center_lat, 5), round(center_lon, 5), route_count, target_distance_km, selected_label, generation_id)
+    key = (round(center_lat, 5), round(center_lon, 5), route_count, target_distance_km, selected_label, generation_id, auto_distance)
     with _LOCK:
         cached = _CACHE.get(key)
     if cached and time.monotonic() - cached[0] < 6 * 3600:
@@ -110,10 +111,13 @@ def generate_walking_fallback(
         perimeter = sum(math.hypot(b[0]-a[0], b[1]-a[1]) for a, b in zip(outline, outline[1:]))
         if perimeter <= 0:
             continue
-        scale = target_distance_km * 1000 / perimeter / 1.2
+        # Auto mode searches several sizes of the same GPX drawing. The
+        # result's measured length, rather than a hidden default, is shown.
+        requested_size_km = (3, 5, 8, 12, 16, 20, 6, 10)[attempt] if auto_distance else target_distance_km
+        scale = requested_size_km * 1000 / perimeter / 1.2
         angle = generation_angle(generation_id) + attempt * math.pi * (3 - math.sqrt(5))
         # Shorter retries also work near a coast or on a small island.
-        size = scale * (1 if attempt < 3 else 0.5 if attempt < 5 else 0.2)
+        size = scale if auto_distance else scale * (1 if attempt < 3 else 0.5 if attempt < 5 else 0.2)
         locations = []
         for x, y in outline:
             dx, dy = (x-outline[0][0]) * size, (y-outline[0][1]) * size
@@ -131,7 +135,7 @@ def generate_walking_fallback(
             trip = response.json().get("trip", {})
             summary = trip.get("summary", {})
             length = float(summary.get("length", 0))
-            if summary.get("has_ferry") or not math.isfinite(length) or length <= 0:
+            if summary.get("has_ferry") or not math.isfinite(length) or length <= 0 or (auto_distance and not 1.5 <= length <= 20):
                 continue
             coords = []
             for leg in trip.get("legs", []):
@@ -165,11 +169,12 @@ def generate_walking_fallback(
     if not routes:
         return None
     routes.sort(key=lambda route: (-route["route_quality"].get("gpx_similarity", 0.0),
-                                   abs(route["length_km"]-target_distance_km)))
+                                   0 if auto_distance else abs(route["length_km"]-target_distance_km)))
     routes = routes[:route_count]
     result = {"place":place or f"{center_lat:.6f},{center_lon:.6f}","source":"point",
         "candidate_count":len(routes),"requested_count":route_count,"generated_count":len(routes),
-        "target_distance_km":target_distance_km,"labels":[selected_label] if selected_label else [],
+        "target_distance_km":routes[0]["length_km"] if auto_distance else target_distance_km,
+        "auto_distance":auto_distance,"labels":[selected_label] if selected_label else [],
         "selected_label":selected_label,"selected_top_k":0,"routes":routes,"best_route":routes[0],
         "generation_mode":"independent_walk_roads",
         "fallback_notice":"주변 실제 보행 도로를 이용해 경로를 생성했습니다. 도로 구조에 따라 선택한 모양과 목표 거리는 달라질 수 있습니다."}

api/ai-service/tests/test_route_generation_recovery.py

@@ -113,6 +113,29 @@ def test_real_independent_roads_are_preferred_to_estimated_preview(pipeline):
     assert result == expected
 
 
+def test_auto_distance_passes_through_to_real_road_fallback(pipeline):
+    pipeline.setattr(routes, "_load_pipeline_module", lambda _: SimpleNamespace(
+        guided_waypoints_for_label=lambda _label: [(0, 0), (1, 0), (1, 1), (0, 0)]))
+    pipeline.setattr(routes, "_run_fast_road_pipeline", Mock(side_effect=RuntimeError("All Overpass endpoints failed")))
+    expected = {"generation_mode": "independent_walk_roads", "routes": [{"estimated_route": False}]}
+    walking = Mock(return_value=expected)
+    pipeline.setattr(routes, "generate_walking_fallback", walking)
+    result = routes.generate_routes(routes.RouteGenerateRequest(
+        source="current", latitude=37.5, longitude=127, selectedLabel="dog", labels=["dog"], autoDistance=True))
+    assert result == expected
+    assert walking.call_args.kwargs["auto_distance"] is True
+
+
+def test_auto_distance_never_returns_estimated_coordinates(pipeline):
+    pipeline.setattr(routes, "_load_pipeline_module", lambda _: SimpleNamespace(
+        guided_waypoints_for_label=lambda _label: [(0, 0), (1, 0), (1, 1), (0, 0)]))
+    pipeline.setattr(routes, "_run_fast_road_pipeline", Mock(side_effect=RuntimeError("All Overpass endpoints failed")))
+    with pytest.raises(routes.HTTPException) as error:
+        routes.generate_routes(routes.RouteGenerateRequest(
+            source="current", latitude=37.5, longitude=127, selectedLabel="dog", labels=["dog"], autoDistance=True))
+    assert error.value.status_code == 503
+
+
 def test_gpx_guided_fast_routes_are_ranked_by_actual_road_similarity(monkeypatch):
     candidates = [
         {"nodes": [1, 2], "length_m": 5900, "shape_quality": 0.8, "is_loop": True},

api/ai-service/tests/test_walking_route_fallback.py

@@ -139,3 +139,21 @@ def test_gpx_fallback_checks_multiple_examples_and_returns_best_match(monkeypatc
     assert all(location['radius'] == 400 for locations_in_request in locations for location in locations_in_request)
     assert result['best_route']['route_quality']['gpx_similarity'] == 0.9
     assert result['generated_count'] == 1
+
+
+def test_auto_distance_tries_multiple_sizes_and_reports_measured_length(monkeypatch):
+    import json
+    response_obj = SimpleNamespace(raise_for_status=lambda: None,
+        json=lambda: {'trip': {'summary': {'length': 4.2, 'has_ferry': False},
+            'legs': [{'shape': encode([[37.5, 127.0], [37.501, 127.002], [37.5, 127.0]])}]}})
+    get = Mock(return_value=response_obj)
+    monkeypatch.setattr(requests, 'get', get)
+    examples = [[(0, 0), (1, 0), (1, 1), (0, 0)]]
+    result = walking.generate_walking_fallback(**options(), templates=examples,
+        generation_id='auto-sizes', auto_distance=True)
+    assert result['target_distance_km'] == 4.2
+    assert result['auto_distance'] is True
+    assert get.call_count == 4
+    first = json.loads(get.call_args_list[0].kwargs['params']['json'])['locations']
+    second = json.loads(get.call_args_list[1].kwargs['params']['json'])['locations']
+    assert first[1] != second[1]

main/app/route-results/[id]/page.tsx

@@ -148,7 +148,7 @@ function GeneratedRouteDetailPageContent() {
       source: "place",
       label: record.routeLabel,
       routeCount: "8",
-      targetDistanceKm: String(Math.max(1, Math.round(record.route.length_km))),
+      autoDistance: "1",
       selectedTopK: "8",
       radiusKm: "2.5",
     });

main/app/route-results/page.tsx

@@ -140,7 +140,6 @@ function RouteResultsPageContent() {
   const initialLongitude = parseNumberParam(searchParams.get("longitude"));
   const initialRadiusKm = parseNumberParam(searchParams.get("radiusKm"));
   const initialCount = parseNumberParam(searchParams.get("routeCount"));
-  const initialDistance = parseNumberParam(searchParams.get("targetDistanceKm"));
   const initialSelectedTopK = parseNumberParam(searchParams.get("selectedTopK"));
   const fallbackLatitude = parseNumberParam(searchParams.get("fallbackLatitude"));
   const fallbackLongitude = parseNumberParam(searchParams.get("fallbackLongitude"));
@@ -148,7 +147,6 @@ function RouteResultsPageContent() {
 
   const [place, setPlace] = useState(initialPlace);
   const [routeCountInput, setRouteCountInput] = useState(Number.isFinite(initialCount) ? String(initialCount) : "8");
-  const [targetDistanceInput, setTargetDistanceInput] = useState(Number.isFinite(initialDistance) ? String(initialDistance) : "5");
   const [loading, setLoading] = useState(false);
   const [error, setError] = useState<string | null>(null);
   const [routeQualityNotice, setRouteQualityNotice] = useState<string | null>(null);
@@ -168,16 +166,15 @@ function RouteResultsPageContent() {
   const regenerateRoutes = () => {
     const requestPlace = place.trim();
     const count = Number(routeCountInput);
-    const distance = Number(targetDistanceInput);
-    if (!requestPlace || !Number.isFinite(count) || count < 5 || count > 100 ||
-      !Number.isFinite(distance) || distance < 1 || distance > 30) {
+    if (!requestPlace || !Number.isFinite(count) || count < 5 || count > 100) {
       void fetchRoutes(); // Keep the same field validation messages.
       return;
     }
     const params = new URLSearchParams(searchParams.toString());
     params.set("place", requestPlace);
     params.set("routeCount", String(count));
-    params.set("targetDistanceKm", String(distance));
+    params.delete("targetDistanceKm");
+    params.set("autoDistance", "1");
     if (requestPlace !== initialPlace.trim()) {
       params.set("source", "place");
       for (const key of ["latitude", "longitude", "fallbackLatitude", "fallbackLongitude"]) params.delete(key);
@@ -192,7 +189,6 @@ function RouteResultsPageContent() {
 
   const fetchRoutes = async () => {
     const routeCount = Number(routeCountInput);
-    const targetDistanceKm = Number(targetDistanceInput);
     const requestPlace = place.trim();
     const placeWasEdited = requestPlace !== initialPlace.trim();
 
@@ -205,10 +201,6 @@ function RouteResultsPageContent() {
       setError("경로 수는 5~100 사이로 입력해주세요.");
       return;
     }
-    if (!Number.isFinite(targetDistanceKm) || targetDistanceKm < 1 || targetDistanceKm > 30) {
-      setError("목표 거리는 1~30km 사이로 입력해주세요.");
-      return;
-    }
 
     activeRequest.current?.abort();
     const controller = new AbortController();
@@ -250,7 +242,7 @@ function RouteResultsPageContent() {
         longitude: placeWasEdited ? null : longitude,
         radiusKm,
         routeCount,
-        targetDistanceKm,
+        autoDistance: true,
         labels: AVAILABLE_LABELS,
         selectedLabel,
         selectedTopK,
@@ -331,8 +323,7 @@ function RouteResultsPageContent() {
       // Store under the request's own key. A separate effect used to write
       // the previous result into the newly selected location's cache.
       try {
-        if (!placeWasEdited && routeCount === (Number.isFinite(initialCount) ? initialCount : 8)
-          && targetDistanceKm === (Number.isFinite(initialDistance) ? initialDistance : 5)) {
+        if (!placeWasEdited && routeCount === (Number.isFinite(initialCount) ? initialCount : 8)) {
           window.sessionStorage.setItem(cacheKey, JSON.stringify(parsed));
         }
       } catch {
@@ -480,7 +471,7 @@ function RouteResultsPageContent() {
         />
 
         <SectionCard>
-          <div className="grid gap-3 sm:grid-cols-[1fr_120px_120px] sm:items-end">
+          <div className="grid gap-3 sm:grid-cols-[1fr_120px] sm:items-end">
             <label className="grid gap-2">
               <span className="rts-label">지역</span>
               <input value={place} onChange={(event) => setPlace(event.target.value)} className="rts-input" />
@@ -489,10 +480,6 @@ function RouteResultsPageContent() {
               <span className="rts-label">경로 수</span>
               <input type="number" min={5} max={100} value={routeCountInput} onChange={(event) => setRouteCountInput(event.target.value)} className="rts-input" />
             </label>
-            <label className="grid gap-2">
-              <span className="rts-label">목표 거리</span>
-              <input type="number" min={1} max={30} step={0.5} value={targetDistanceInput} onChange={(event) => setTargetDistanceInput(event.target.value)} className="rts-input" />
-            </label>
           </div>
 
           {error ? <p className="mt-3 text-sm text-red-600">{error}</p> : null}
@@ -517,8 +504,8 @@ function RouteResultsPageContent() {
                 <span>추천 경로</span>
               </div>
               <div>
-                <strong>{formatDistance(result.target_distance_km)}</strong>
-                <span>목표 거리</span>
+                <strong>{result.best_route ? formatDistance(result.best_route.length_km) : "-"}</strong>
+                <span>첫 번째 경로 거리</span>
               </div>
               <div>
                 <strong>{formatGeneratedRouteLabel(selectedLabel)}</strong>

main/app/route-search/page.tsx

@@ -499,13 +499,11 @@ function RouteSearchPageContent() {
   const [isRegionPickerOpen, setIsRegionPickerOpen] = useState(false);
   const [isDistrictPickerOpen, setIsDistrictPickerOpen] = useState(false);
   const [isShapePickerOpen, setIsShapePickerOpen] = useState(false);
-  const [isDistancePickerOpen, setIsDistancePickerOpen] = useState(false);
   const [latitude, setLatitude] = useState<number | null>(null);
   const [longitude, setLongitude] = useState<number | null>(null);
   const [locationAccuracyM, setLocationAccuracyM] = useState<number | null>(null);
   const [radiusKm, setRadiusKm] = useState(2.5);
   const [routeCountInput, setRouteCountInput] = useState("5");
-  const [targetDistanceInput, setTargetDistanceInput] = useState("6");
   const [selectedLabel, setSelectedLabel] = useState(requestedLabel || "cloud");
   const [geoError, setGeoError] = useState<string | null>(null);
   const [locationPermissionState, setLocationPermissionState] =
@@ -528,7 +526,6 @@ function RouteSearchPageContent() {
   );
   const districtOptions = activeRegion.districts;
   const routeCountPresets = [5, 8, 16];
-  const distanceOptions = [3, 5, 7, 8, 10, 12, 16];
   const radiusPresets = [2.5, 5, 10];
   const labelOptions = useMemo(() => SHAPE_OPTIONS.map((shape) => shape.key), []);
   const selectedShape =
@@ -604,8 +601,8 @@ function RouteSearchPageContent() {
       : [];
   const isWaitingForCurrentLocation = isLocating;
   const summaryPlace = source === "current" ? "현재 위치" : selectedDistrictLabel;
-  const selectedSummary = `${summaryPlace} · ${selectedShape.label} · ${targetDistanceInput || "-"}km`;
-  const routePlanText = `${summaryPlace}에서 ${selectedShape.label} 모양에 가까운 ${targetDistanceInput || "-"}km 경로를 ${routeCountInput || "-"}개 추천합니다.`;
+  const selectedSummary = `${summaryPlace} · ${selectedShape.label} · 거리 자동`;
+  const routePlanText = `${summaryPlace}에서 목표 거리를 정하지 않고 ${selectedShape.label} 모양에 가까운 경로를 찾아 ${routeCountInput || "-"}개 추천합니다.`;
 
   useEffect(() => {
     const isValid = isUiFlowPermitValid(FLOW_KEYS.routeSearch, flowToken);
@@ -771,26 +768,17 @@ function RouteSearchPageContent() {
     }
 
     const routeCount = Number(routeCountInput);
-    const targetDistanceKm = Number(targetDistanceInput);
     if (!Number.isFinite(routeCount) || routeCount < 5 || routeCount > 100) {
       setFormError("추천 경로 수는 5~100 사이 숫자로 입력해 주세요.");
       return;
     }
-    if (
-      !Number.isFinite(targetDistanceKm) ||
-      targetDistanceKm < 1 ||
-      targetDistanceKm > 30
-    ) {
-      setFormError("목표 거리는 1~30km 사이 숫자로 입력해 주세요.");
-      return;
-    }
     setIsNavigating(true);
     const params = new URLSearchParams({
       source: effectiveSource,
       place: effectivePlace,
       radiusKm: String(radiusKm),
       routeCount: String(routeCount),
-      targetDistanceKm: String(targetDistanceKm),
+      autoDistance: "1",
       label: selectedLabel,
       selectedTopK: "3",
       // Supply the visible map centre for a server-side recovery attempt when
@@ -932,7 +920,6 @@ function RouteSearchPageContent() {
                       setIsRegionPickerOpen((open) => !open);
                       setIsDistrictPickerOpen(false);
                       setIsShapePickerOpen(false);
-                      setIsDistancePickerOpen(false);
                     }}
                     className="flex h-12 w-full items-center justify-between rounded-2xl border border-black/10 bg-[#f7f7f7] px-4 text-left text-sm font-semibold"
                   >
@@ -988,7 +975,6 @@ function RouteSearchPageContent() {
                       setIsDistrictPickerOpen((open) => !open);
                       setIsRegionPickerOpen(false);
                       setIsShapePickerOpen(false);
-                      setIsDistancePickerOpen(false);
                     }}
                     className="flex h-12 w-full items-center justify-between rounded-2xl border border-black/10 bg-[#f7f7f7] px-4 text-left text-sm font-semibold"
                   >
@@ -1060,8 +1046,8 @@ function RouteSearchPageContent() {
             </div>
           </section>
 
-          <section className={`relative rounded-[28px] border border-black/10 bg-white p-5 shadow-[0_18px_45px_rgba(0,0,0,0.06)] ${isShapePickerOpen || isDistancePickerOpen ? "z-[2400]" : ""}`}>
-            <h2 className="text-xl font-bold">모양과 거리</h2>
+          <section className={`relative rounded-[28px] border border-black/10 bg-white p-5 shadow-[0_18px_45px_rgba(0,0,0,0.06)] ${isShapePickerOpen ? "z-[2400]" : ""}`}>
+            <h2 className="text-xl font-bold">모양</h2>
 
             <div className="mt-4 grid gap-4">
               <label className="grid gap-2">
@@ -1073,7 +1059,6 @@ function RouteSearchPageContent() {
                       setIsShapePickerOpen((open) => !open);
                       setIsRegionPickerOpen(false);
                       setIsDistrictPickerOpen(false);
-                      setIsDistancePickerOpen(false);
                     }}
                     className="flex h-12 w-full items-center justify-between rounded-2xl border border-black/10 bg-[#f7f7f7] px-4 text-left text-sm font-semibold"
                   >
@@ -1113,56 +1098,6 @@ function RouteSearchPageContent() {
                 </div>
               </label>
 
-              <label className="grid gap-2">
-                <span className="text-sm font-bold">목표 거리</span>
-                <div className="relative">
-                  <button
-                    type="button"
-                    onClick={() => {
-                      setIsDistancePickerOpen((open) => !open);
-                      setIsRegionPickerOpen(false);
-                      setIsDistrictPickerOpen(false);
-                      setIsShapePickerOpen(false);
-                    }}
-                    className="flex h-12 w-full items-center justify-between rounded-2xl border border-black/10 bg-[#f7f7f7] px-4 text-left text-sm font-semibold"
-                  >
-                    <span>{targetDistanceInput || "-"}km</span>
-                    <span className="ml-3 text-xs text-[#666]">
-                      {isDistancePickerOpen ? "▲" : "▼"}
-                    </span>
-                  </button>
-
-                  <MotionPopover
-                    open={isDistancePickerOpen}
-                    className="absolute left-0 right-0 top-[54px] z-[2300] max-h-[308px] overflow-y-auto rounded-2xl border border-black/10 bg-white py-2 shadow-[0_14px_34px_rgba(0,0,0,0.16)]"
-                  >
-                      {distanceOptions.map((distance) => {
-                        const value = String(distance);
-                        const isSelected = targetDistanceInput === value;
-
-                        return (
-                          <button
-                            key={distance}
-                            type="button"
-                            onMouseDown={(event) => event.preventDefault()}
-                            onClick={() => {
-                              setTargetDistanceInput(value);
-                              setIsDistancePickerOpen(false);
-                            }}
-                            className={`flex h-11 w-full items-center px-4 text-left text-sm font-semibold ${
-                              isSelected
-                                ? "bg-[#1E40AF] text-white"
-                                : "text-black hover:bg-[#f3f7ff]"
-                            }`}
-                          >
-                            {distance}km
-                          </button>
-                        );
-                      })}
-                  </MotionPopover>
-                </div>
-              </label>
-
               <details className="rounded-2xl bg-[#f7f7f7] p-4">
                 <summary className="cursor-pointer text-sm font-bold">세부 설정</summary>
                 <div className="mt-4 grid gap-4">

router/ai/scripts/clip_osm_region_test.py

@@ -2387,6 +2387,7 @@ def generate_candidate_routes(
     target_distance_m: float,
     tolerance_ratio: float = 0.35,
     selected_label: str | None = None,
+    auto_distance: bool = False,
 ) -> list[dict[str, Any]]:
     nodes = list(graph.nodes)
     if len(nodes) < 8:
@@ -2415,10 +2416,11 @@ def generate_candidate_routes(
         shuffled_examples = random.sample(examples, len(examples)) if examples else []
         for attempt in range(guided_attempts):
             try:
+                guided_target_m = (3000.0, 5000.0, 8000.0, 12000.0, 16000.0)[attempt % 5] if auto_distance else target_distance_m
                 geo_points = guided_geo_waypoints(
                     graph=graph,
                     label=str(selected_label),
-                    target_distance_m=target_distance_m,
+                    target_distance_m=guided_target_m,
                     template=shuffled_examples[attempt % len(shuffled_examples)] if shuffled_examples else None,
                 )
                 waypoint_nodes = nearest_nodes_for_geo_points(graph, geo_points)
@@ -2429,7 +2431,7 @@ def generate_candidate_routes(
             if len(route_nodes) < 18:
                 continue
             length_m = route_length_m(graph, route_nodes)
-            if length_m <= 0:
+            if length_m <= 0 or (auto_distance and not 1500.0 <= length_m <= 20000.0):
                 continue
             unique_ratio = len(set(route_nodes)) / len(route_nodes)
             if unique_ratio < 0.50:
@@ -2481,10 +2483,20 @@ def generate_candidate_routes(
                     selected_label, shape_metrics, is_loop=True
                 ),
             }
-            if delta <= tolerance:
+            if delta <= tolerance or auto_distance:
                 accepted.append(row)
             fallback.append(row)
 
+    if auto_distance and selected_label:
+        # Automatic sizing is a drawing search. Random loops cannot satisfy
+        # the requested label, so spend the remaining time ranking guided
+        # road routes instead of generating hundreds of unrelated loops.
+        accepted.sort(key=lambda route: (
+            -float(route.get("shape_quality", 0.0)),
+            -float(route.get("label_generation_prior", 0.0)),
+        ))
+        return accepted[:max(route_count, 24)]
+
     # 2) closed-loop random candidates
     for _ in range(max_attempts):
         try:
@@ -2512,7 +2524,7 @@ def generate_candidate_routes(
             continue
 
         length_m = route_length_m(graph, route_nodes)
-        if length_m <= 0:
+        if length_m <= 0 or (auto_distance and not 1500.0 <= length_m <= 20000.0):
             continue
         unique_ratio = len(set(route_nodes)) / len(route_nodes)
         if unique_ratio < 0.55:
@@ -2570,7 +2582,7 @@ def generate_candidate_routes(
                 selected_label, shape_metrics, is_loop=True
             ),
         }
-        if delta <= tolerance:
+        if delta <= tolerance or auto_distance:
             accepted.append(row)
         fallback.append(row)
 
@@ -2591,7 +2603,7 @@ def generate_candidate_routes(
             if len(route_nodes) < 10:
                 continue
             length_m = route_length_m(graph, route_nodes)
-            if length_m <= 0:
+            if length_m <= 0 or (auto_distance and not 1500.0 <= length_m <= 20000.0):
                 continue
             pts = route_points(graph, route_nodes)
             shape_quality, shape_metrics = route_shape_quality_with_metrics(pts, close_loop=False)
@@ -2639,7 +2651,7 @@ def generate_candidate_routes(
                     selected_label, shape_metrics, is_loop=False
                 ),
             }
-            if delta <= tolerance:
+            if delta <= tolerance or auto_distance:
                 accepted.append(row)
             fallback.append(row)
 
@@ -2647,7 +2659,7 @@ def generate_candidate_routes(
         key=lambda x: (
             -generation_mode_priority(x),
             -float(x.get("label_generation_prior", 0.0)),
-            x["delta"],
+            *((x["delta"],) if not auto_distance else ()),
             -float(x.get("shape_quality", 0.0)),
             -len(x["nodes"]),
         )