diff --git a/src/components/map/Map.search-rank.test.tsx b/src/components/map/Map.search-rank.test.tsx
index 1760aa39..5d2c006d 100644
--- a/src/components/map/Map.search-rank.test.tsx
+++ b/src/components/map/Map.search-rank.test.tsx
@@ -46,6 +46,7 @@ vi.mock("@/contexts/MobileViewContext", () => ({
 }));
 vi.mock("@/hooks/usePlacesSearch", () => ({
   fetchPlacesPageWithPhotos: boundary.page,
+  fetchPlacesAreaPage: vi.fn(),
 }));
 vi.mock("@/lib/analytics/track", () => ({
   AnalyticsEvents: { search: "view_search_results", viewPlace: "view_place" },
diff --git a/src/components/map/Map.search-selection.test.tsx b/src/components/map/Map.search-selection.test.tsx
index 2b7ede63..9adf5e06 100644
--- a/src/components/map/Map.search-selection.test.tsx
+++ b/src/components/map/Map.search-selection.test.tsx
@@ -50,6 +50,7 @@ vi.mock("@/contexts/MobileViewContext", () => ({
 }));
 vi.mock("@/hooks/usePlacesSearch", () => ({
   fetchPlacesPageWithPhotos: boundary.page,
+  fetchPlacesAreaPage: vi.fn(),
 }));
 vi.mock("@/lib/analytics/track", () => ({
   AnalyticsEvents: { search: "search" },
diff --git a/src/components/map/Map.tsx b/src/components/map/Map.tsx
index 3abf7dcd..78270004 100644
--- a/src/components/map/Map.tsx
+++ b/src/components/map/Map.tsx
@@ -39,6 +39,7 @@ import {
 import { MAP_DETAIL_PANEL_COVER_WIDTH_PX } from "@/lib/layout-tokens";
 import { isPlanPath } from "@/lib/layout/mainChromeLayoutWidth";
 import { isMobileMapPathname } from "@/lib/mobile-view";
+import { settleSearchSnapshotAfterMove } from "@/lib/map-viewport-commit";
 import { clampPlacesSearchRadiusMeters } from "@/lib/places/placesSearchRadius";
 import { useMapCenterStore } from "@/stores/map-center-store";
 import { useSearchRecenterStore } from "@/stores/search-recenter-store";
@@ -194,6 +195,7 @@ function MapBootstrapSync({
       mapCenter: { lat, lng },
       zoom: mapZoom,
       radiusMeters,
+      bounds: bounds?.toJSON() ?? null,
     });
   }, [map, ready, center.lat, center.lng, zoom, roomId, setMapCamera]);
 
@@ -291,7 +293,9 @@ function MapSearchResultPins() {
   const selectedPlaceId = isMobileDevice && !selectedPlace ? searchSelectedId ?? "" : selectedPlace?.googlePlaceId?.trim() ?? "";
 
   useEffect(() => {
-    if (map && preview) panToWithinWorld(map, preview.location);
+    if (!map || !preview) return;
+    panToWithinWorld(map, preview.location);
+    return settleSearchSnapshotAfterMove(map);
   }, [map, preview]);
 
   // 전체 검색 결과가 준비되면 첫 추천 대신 실제 결과들이 보이도록 맞춘다.
@@ -305,6 +309,7 @@ function MapSearchResultPins() {
       items.forEach((item) => bounds.extend(item.location));
       map.fitBounds(bounds, 80);
     }
+    return settleSearchSnapshotAfterMove(map);
   }, [map, isMobileDevice, pinsFocus, kind, status, items]);
 
   if (pinsFocus !== "search") return null;
@@ -396,6 +401,8 @@ export default function TripMap({
   );
   const [rating, setRating] = useState<RatingValue>("all");
   const [openNow, setOpenNow] = useState<OpenValue>("all");
+  // 카테고리 검색이 실패하면 「현 위치에서 검색」 버튼이 「다시 시도」로 남는다
+  const [discoverFailed, setDiscoverFailed] = useState(false);
   const [showBookmarkPins, setShowBookmarkPins] = useState(true);
 
   // Text search takes over the map at request start, including autocomplete selection.
@@ -461,6 +468,7 @@ export default function TripMap({
         mapCenter: { lat: center.lat, lng: center.lng },
         zoom,
         radiusMeters,
+        bounds,
       });
 
       const rid =
@@ -595,7 +603,7 @@ export default function TripMap({
           {routeView ? <RouteViewMarkers routeView={routeView} /> : (
             <>
               <PlanItineraryMapRoutes />
-              <MapDiscoverPlaces selectedCategoryId={selectedCategoryId} rating={rating} openNow={openNow} />
+              <MapDiscoverPlaces selectedCategoryId={selectedCategoryId} rating={rating} openNow={openNow} onSearchFailedChange={setDiscoverFailed} />
               <MapBookmarkPins roomId={currentRoomId} enabled={showBookmarkPins}
                 hiddenNormalizedPlaceIds={isPlanPage ? planStopPlaceIds : undefined} />
               <MapSearchResultPins />
@@ -649,7 +657,7 @@ export default function TripMap({
 
       {!bootstrap.ready || routeView ? null : (
         <>
-          {planRouteMode ? null : <MapSearchHereButton discoverCategoryId={selectedCategoryId} />}
+          {planRouteMode ? null : <MapSearchHereButton discoverCategoryId={selectedCategoryId} discoverFailed={discoverFailed} />}
           {isMobileDevice ? (
             <div className="pointer-events-none absolute bottom-6 left-4 z-[16] flex flex-col items-center gap-3">
               {onOpenRouteView ? (
@@ -770,7 +778,9 @@ function MobileSearchSelection() {
   const lat = item?.location.lat;
   const lng = item?.location.lng;
   useEffect(() => {
-    if (map && focus === "search" && !selectedPlace && lat != null && lng != null) panToWithinWorld(map, { lat, lng });
+    if (!map || focus !== "search" || selectedPlace || lat == null || lng == null) return;
+    panToWithinWorld(map, { lat, lng });
+    return settleSearchSnapshotAfterMove(map);
   }, [map, focus, selectedPlace, selectedId, lat, lng]);
   if (!item || focus !== "search" || selectedPlace) return null;
   return <AdvancedMarker position={item.location} onClick={(event) => event.stop()}><span className="block text-primary drop-shadow-md"><MapPinIcon size={MAP_PIN_SELECTED_DISPLAY_SIZE_PX} {...mapPinBodyBorderProps} /></span></AdvancedMarker>;
diff --git a/src/components/map/MapDiscoverPlaces.tsx b/src/components/map/MapDiscoverPlaces.tsx
index ef6de3b3..d8cf01df 100644
--- a/src/components/map/MapDiscoverPlaces.tsx
+++ b/src/components/map/MapDiscoverPlaces.tsx
@@ -63,6 +63,8 @@ export type MapDiscoverPlacesProps = {
   selectedCategoryId: string | null;
   rating: RatingValue;
   openNow: OpenValue;
+  /** 검색이 실패하면 true, 새 검색을 시작하면 false. 바뀌지 않는 함수(useState의 set)를 넘긴다 */
+  onSearchFailedChange: (failed: boolean) => void;
 };
 
 function DiscoverMarkerPin({
@@ -115,6 +117,7 @@ export function MapDiscoverPlaces({
   selectedCategoryId,
   rating,
   openNow,
+  onSearchFailedChange,
 }: MapDiscoverPlacesProps) {
   const map = useMap();
   const placesLib = useMapsLibrary("places");
@@ -140,6 +143,7 @@ export function MapDiscoverPlaces({
       writeEpoch: number,
     ) => {
       const seq = ++searchSeqRef.current;
+      onSearchFailedChange(false);
 
       if (!placesLib) {
         if (
@@ -237,9 +241,10 @@ export function MapDiscoverPlaces({
           return;
         }
         setMarkers([]);
+        onSearchFailedChange(true);
       }
     },
-    [placesLib],
+    [placesLib, onSearchFailedChange],
   );
 
   /** Search가 맵 핀 소유 시 디스커버 마커 비우기·비행 응답 무효화 */
diff --git a/src/components/map/MapPlaceSearch.test.tsx b/src/components/map/MapPlaceSearch.test.tsx
index 63a13fd2..ffd51012 100644
--- a/src/components/map/MapPlaceSearch.test.tsx
+++ b/src/components/map/MapPlaceSearch.test.tsx
@@ -30,6 +30,7 @@ vi.mock("@/contexts/SelectedPlaceContext", () => ({
 }));
 vi.mock("@/hooks/usePlacesSearch", () => ({
   fetchPlacesPageWithPhotos: boundary.page,
+  fetchPlacesAreaPage: vi.fn(),
 }));
 vi.mock("@/lib/analytics/track", () => ({
   AnalyticsEvents: { search: "search" },
@@ -84,9 +85,7 @@ it("specific Details failure retry returns to that input with a fresh session an
     (buttons[1] as HTMLButtonElement).click();
   });
   expect(usePlaceSearchStore.getState().status).toBe("error");
-  const retry = [...host.querySelectorAll("button")].find(
-    (button) => button.textContent === "다시 시도",
-  )!;
+  const retry = host.querySelector<HTMLButtonElement>('button[aria-label="다시 시도"]')!;
   await act(async () => retry.click());
   expect(boundary.page).not.toHaveBeenCalled();
   expect(document.activeElement).toBe(input);
@@ -106,3 +105,21 @@ it("specific Details failure retry returns to that input with a fresh session an
   expect(boundary.page).not.toHaveBeenCalled();
   expect(usePlaceSearchStore.getState().selectedId).toBe("chosen");
 });
+// 버튼으로 한 「현 위치에서 검색」의 결과 없음은 검색창 아래가 아니라 버튼 자리에서 알린다
+it("search here no results stay out of the search box", async () => {
+  useSessionStore.setState({ currentRoomId: "room" });
+  useMapCenterStore.setState({ mapCenter: { lat: 1, lng: 2 } });
+  usePlaceSearchStore.getState().clear();
+  const host = document.createElement("div");
+  document.body.append(host);
+  const root = createRoot(host);
+  cleanup = async () => {
+    await act(async () => root.unmount());
+    host.remove();
+  };
+  await act(async () => root.render(<MapPlaceSearch mobile={false} />));
+  await act(async () => usePlaceSearchStore.setState({ searchMode: "map_recenter", status: "done", items: [] }));
+  expect(host.textContent).not.toContain("검색 결과가 없어요");
+  await act(async () => usePlaceSearchStore.setState({ searchMode: "text" }));
+  expect(host.textContent).toContain("검색 결과가 없어요");
+});
diff --git a/src/components/map/MapPlaceSearch.tsx b/src/components/map/MapPlaceSearch.tsx
index 32954c3e..dd528959 100644
--- a/src/components/map/MapPlaceSearch.tsx
+++ b/src/components/map/MapPlaceSearch.tsx
@@ -2,6 +2,7 @@
 
 import { useRef } from "react";
 import { flushSync } from "react-dom";
+import { RefreshIcon } from "@/assets/icons";
 import { useMobileMapSearchStore } from "@/stores/mobile-map-search-store";
 import { useSearchParams } from "next/navigation";
 import { MapPlaceSearchInput } from "@/components/search/MapPlaceSearchInput";
@@ -26,6 +27,7 @@ export function MapPlaceSearch({ mobile, hidden = false }: Readonly<{
   const items = usePlaceSearchStore((s) => s.items);
   const inputRef = useRef<HTMLInputElement>(null);
   const confirmationKind = usePlaceSearchStore((s) => s.confirmationKind);
+  const searchMode = usePlaceSearchStore((s) => s.searchMode);
   const query = usePlaceSearchStore((s) => s.query);
   const focus = useMapPinsFocusStore((s) => s.focus);
   const { selectedPlace } = useSelectedPlace();
@@ -44,8 +46,9 @@ export function MapPlaceSearch({ mobile, hidden = false }: Readonly<{
     }
     void confirm({ query, kind: "whole", session: null, generation: 0 });
   };
-  const hasFeedback = status === "pending" || status === "error" ||
-    (status === "done" && !items.length);
+  // 「현 위치에서 검색」의 실패·결과 없음은 검색창이 아니라 그 버튼 자리에서 알린다(MapSearchHereButton)
+  const hasFeedback = status === "pending" || (searchMode === "text" &&
+    (status === "error" || (status === "done" && !items.length)));
   const feedback = hasFeedback ? (
     <SearchFeedback status={status} error={error} hasItems={items.length > 0} retry={retry} />
   ) : null;
@@ -63,7 +66,7 @@ export function MapPlaceSearch({ mobile, hidden = false }: Readonly<{
         <div
           data-tutorial-target="search"
           hidden={hidden}
-          className="pointer-events-auto relative min-w-0 max-w-[calc(100%-60px)] shrink-0"
+          className="group/search pointer-events-auto relative min-w-0 max-w-[calc(100%-60px)] shrink-0"
         >
           <MapPlaceSearchInput
             key={`${scopeKey}:${initialQuery}`}
@@ -76,8 +79,9 @@ export function MapPlaceSearch({ mobile, hidden = false }: Readonly<{
             onInvalidate={invalidate}
             onClear={clearSearch}
           />
+          {/* 다시 검색하려고 검색창에 들어가면 추천 목록과 같은 자리라 안내를 숨긴다 */}
           {feedback ? (
-            <div className="absolute right-0 top-full mt-1 w-[353px] max-w-full rounded-lg border border-border-subtle bg-fill-subtle p-3">
+            <div className="absolute right-0 top-full mt-1 w-[353px] max-w-full rounded-lg border border-border-subtle bg-fill-subtle p-3 group-has-[input:focus]/search:hidden">
               {feedback}
             </div>
           ) : null}
@@ -103,10 +107,12 @@ function SearchFeedback({ status, error, hasItems, retry }: Readonly<{
 }>) {
   if (status === "pending") return <Spinner aria-label="장소 검색 중" />;
   if (status === "error") return (
-    <div role="alert" className="flex items-center gap-2 text-body-s-regular text-text">
-      <span>{error}</span>
-      <button type="button" className="shrink-0 cursor-pointer text-primary underline hover:opacity-80 focus-visible:outline-2 focus-visible:outline-primary" onClick={retry}>
-        다시 시도
+    <div role="alert" className="flex items-center justify-between gap-2 text-body-s-regular text-text">
+      <span className="min-w-0">{error}</span>
+      {/* 아이콘은 20px, 누르는 영역은 44px */}
+      <button type="button" aria-label="다시 시도" onClick={retry}
+        className="-m-3 grid size-11 shrink-0 cursor-pointer place-items-center text-icon-subtle hover:opacity-80 focus-visible:outline-2 focus-visible:outline-primary">
+        <RefreshIcon size={20} />
       </button>
     </div>
   );
diff --git a/src/components/map/MapSearchHereButton.test.tsx b/src/components/map/MapSearchHereButton.test.tsx
new file mode 100644
index 00000000..2688237b
--- /dev/null
+++ b/src/components/map/MapSearchHereButton.test.tsx
@@ -0,0 +1,88 @@
+// @vitest-environment jsdom
+import { act } from "react";
+import { createRoot, type Root } from "react-dom/client";
+import { afterEach, beforeEach, expect, it } from "vitest";
+import { MapSearchHereButton } from "./MapSearchHereButton";
+import { useMapCenterStore } from "@/stores/map-center-store";
+import { usePlaceSearchStore } from "@/stores/place-search-store";
+import { useSearchRecenterStore } from "@/stores/search-recenter-store";
+
+let root: Root, host: HTMLDivElement;
+const searched = { center: { lat: 35.7, lng: 139.8 }, zoom: 15, radius: 1000 };
+
+beforeEach(async () => {
+  Object.assign(globalThis, { IS_REACT_ACT_ENVIRONMENT: true });
+  usePlaceSearchStore.getState().clear();
+  useMapCenterStore.setState({ mapCenter: searched.center, zoom: 15 });
+  useSearchRecenterStore.getState().setSearchSnapshot(searched);
+  host = document.createElement("div");
+  root = createRoot(host);
+  await act(async () => root.render(<MapSearchHereButton discoverCategoryId={null} discoverFailed={false} />));
+});
+afterEach(async () => {
+  await act(async () => root.unmount());
+  useSearchRecenterStore.getState().clearSearchSnapshot();
+  useSearchRecenterStore.getState().clearDiscoverSnapshot();
+  usePlaceSearchStore.getState().clear();
+});
+
+const button = () => host.querySelector("button");
+const notice = () => host.querySelector('[role="status"]');
+const finishSearch = (state: Partial<ReturnType<typeof usePlaceSearchStore.getState>>) =>
+  act(async () => usePlaceSearchStore.setState(state));
+
+it("shows nothing while the map shows the searched area", () => {
+  expect(button()).toBeNull();
+});
+
+it("turns into 다시 시도 when search here fails and asks search here again", async () => {
+  await finishSearch({ searchMode: "map_recenter", status: "error" });
+  expect(button()?.textContent).toBe("다시 시도");
+  const before = useSearchRecenterStore.getState().searchRecenterRequestId;
+  await act(async () => button()!.click());
+  expect(useSearchRecenterStore.getState().searchRecenterRequestId).toBe(before + 1);
+});
+
+it("a search box failure leaves the button alone", async () => {
+  await finishSearch({ searchMode: "text", status: "error" });
+  expect(button()).toBeNull();
+});
+
+it("shows 검색 결과가 없어요 until closed, and again for the next search here", async () => {
+  await finishSearch({ searchMode: "map_recenter", status: "done", items: [] });
+  expect(notice()?.textContent).toBe("검색 결과가 없어요");
+  await act(async () => host.querySelector<HTMLButtonElement>('button[aria-label="안내 닫기"]')!.click());
+  expect(notice()).toBeNull();
+  await act(async () => { usePlaceSearchStore.getState().invalidate(); });
+  await finishSearch({ searchMode: "map_recenter", status: "done", items: [] });
+  expect(notice()).not.toBeNull();
+});
+
+it("goes back to 현 위치에서 검색 when the map moves after a failure", async () => {
+  await finishSearch({ searchMode: "map_recenter", status: "error" });
+  await act(async () => useMapCenterStore.setState({ mapCenter: { lat: 35.8, lng: 139.8 } }));
+  expect(button()?.textContent).toBe("현 위치에서 검색");
+});
+
+// 카테고리 칩으로 찾은 뒤 「현 위치에서 검색」이 실패해도(결과 없음이 아니라 오류) 같은 자리에서 다시 시도한다
+it("turns into 다시 시도 when the category search fails and asks the category search again", async () => {
+  useSearchRecenterStore.getState().setDiscoverSnapshot({
+    ...searched,
+    bounds: { south: 35.69, west: 139.79, north: 35.71, east: 139.81 },
+  });
+  await act(async () => root.render(<MapSearchHereButton discoverCategoryId="restaurant" discoverFailed />));
+  expect(button()?.textContent).toBe("다시 시도");
+  const before = useSearchRecenterStore.getState().discoverRecenterRequestId;
+  await act(async () => button()!.click());
+  expect(useSearchRecenterStore.getState().discoverRecenterRequestId).toBe(before + 1);
+});
+
+it("goes back to 현 위치에서 검색 when the map moves after a category failure", async () => {
+  useSearchRecenterStore.getState().setDiscoverSnapshot({
+    ...searched,
+    bounds: { south: 35.69, west: 139.79, north: 35.71, east: 139.81 },
+  });
+  await act(async () => root.render(<MapSearchHereButton discoverCategoryId="restaurant" discoverFailed />));
+  await act(async () => useMapCenterStore.setState({ mapCenter: { lat: 35.8, lng: 139.8 } }));
+  expect(button()?.textContent).toBe("현 위치에서 검색");
+});
diff --git a/src/components/map/MapSearchHereButton.tsx b/src/components/map/MapSearchHereButton.tsx
index bb16838e..f4c14cb8 100644
--- a/src/components/map/MapSearchHereButton.tsx
+++ b/src/components/map/MapSearchHereButton.tsx
@@ -1,15 +1,25 @@
 "use client";
 
-import { SearchHereFloatingButton } from "@/components/map/SearchHereFloatingButton";
+import { useState } from "react";
+import { CloseIcon } from "@/assets/icons";
+import {
+  SearchHereFloatingButton,
+  searchHerePillClass,
+} from "@/components/map/SearchHereFloatingButton";
 import { usePlacesSearchHereVisible } from "@/components/map/usePlacesSearchHereVisible";
+import { cn } from "@/lib/utils";
+import { usePlaceSearchStore } from "@/stores/place-search-store";
 import { useSearchRecenterStore } from "@/stores/search-recenter-store";
 
 export type MapSearchHereButtonProps = {
   discoverCategoryId: string | null;
+  /** 카테고리 검색이 실패함 — 버튼이 「다시 시도」로 남는다 */
+  discoverFailed: boolean;
 };
 
 export function MapSearchHereButton({
   discoverCategoryId,
+  discoverFailed,
 }: MapSearchHereButtonProps) {
   const requestSearchRecenter = useSearchRecenterStore(
     (s) => s.requestSearchRecenter,
@@ -17,21 +27,54 @@ export function MapSearchHereButton({
   const requestDiscoverRecenter = useSearchRecenterStore(
     (s) => s.requestDiscoverRecenter,
   );
-  const { visible, suggestSearchRecenter, suggestDiscoverRecenter } =
-    usePlacesSearchHereVisible({ discoverCategoryId });
+  const generation = usePlaceSearchStore((s) => s.generation);
+  // 닫은 「검색 결과가 없어요」는 그 검색 동안만 닫혀 있다(새 검색은 generation이 바뀐다)
+  const [closedGeneration, setClosedGeneration] = useState<number | null>(null);
+  const {
+    visible,
+    suggestSearchRecenter,
+    searchRecenterNotice,
+    suggestDiscoverRecenter,
+    retryDiscoverRecenter,
+  } = usePlacesSearchHereVisible({ discoverCategoryId, discoverFailed });
+  const showEmptyNotice =
+    searchRecenterNotice === "empty" && closedGeneration !== generation;
+
+  if (!visible && !showEmptyNotice) return null;
 
   return (
-    <SearchHereFloatingButton
-      visible={visible}
-      onPress={() => {
-        if (suggestSearchRecenter) {
-          requestSearchRecenter();
-          return;
-        }
-        if (suggestDiscoverRecenter) {
-          requestDiscoverRecenter();
-        }
-      }}
-    />
+    <div className="pointer-events-none absolute bottom-6 left-1/2 z-[17] -translate-x-1/2">
+      {showEmptyNotice ? (
+        <div role="status" className={cn(searchHerePillClass, "pe-1")}>
+          검색 결과가 없어요
+          {/* 아이콘은 16px, 누르는 영역은 32×44px(세로는 음수 margin으로 알약 높이 유지) */}
+          <button
+            type="button"
+            aria-label="안내 닫기"
+            onClick={() => setClosedGeneration(generation)}
+            className="-my-3 grid h-11 w-8 shrink-0 cursor-pointer place-items-center text-primary focus-visible:outline-2 focus-visible:outline-primary"
+          >
+            <CloseIcon size={16} />
+          </button>
+        </div>
+      ) : (
+        <SearchHereFloatingButton
+          label={
+            searchRecenterNotice === "failed" || retryDiscoverRecenter
+              ? "다시 시도"
+              : "현 위치에서 검색"
+          }
+          onPress={() => {
+            if (suggestSearchRecenter) {
+              requestSearchRecenter();
+              return;
+            }
+            if (suggestDiscoverRecenter) {
+              requestDiscoverRecenter();
+            }
+          }}
+        />
+      )}
+    </div>
   );
 }
diff --git a/src/components/map/MobileMapSearch.tsx b/src/components/map/MobileMapSearch.tsx
index a8eb89ae..ad972197 100644
--- a/src/components/map/MobileMapSearch.tsx
+++ b/src/components/map/MobileMapSearch.tsx
@@ -61,6 +61,7 @@ export function MobileMapSearch({
     usePlaceSearchStore.setState({
       query: entry.name,
       confirmationKind: "specific",
+      searchMode: "text",
       status: "pending",
       error: null,
     });
@@ -89,7 +90,6 @@ export function MobileMapSearch({
         expanded: false,
         status: "done",
         error: null,
-        fallback: false,
         termination: "not-requested",
         resolution: null,
         query: item.name,
diff --git a/src/components/map/SearchHereFloatingButton.tsx b/src/components/map/SearchHereFloatingButton.tsx
index 5ece72c0..f7d898b0 100644
--- a/src/components/map/SearchHereFloatingButton.tsx
+++ b/src/components/map/SearchHereFloatingButton.tsx
@@ -1,32 +1,33 @@
 "use client";
 
 import { RefreshCw } from "lucide-react";
+import { cn } from "@/lib/utils";
+
+/** 지도 하단 「현 위치에서 검색」 알약 모양. 같은 자리의 「검색 결과가 없어요」 안내도 이 모양을 쓴다 */
+export const searchHerePillClass =
+  "pointer-events-auto inline-flex items-center gap-1 rounded-full border-3 border-primary bg-white px-3 py-2 text-label-m-emphasis mobile:text-label-s-emphasis font-semibold text-dark-gray shadow-md";
 
 type SearchHereFloatingButtonProps = {
-  visible: boolean;
+  label: string;
   onPress: () => void;
 };
 
 export function SearchHereFloatingButton({
-  visible,
+  label,
   onPress,
 }: SearchHereFloatingButtonProps) {
-  if (!visible) return null;
-
   return (
-    <div className="pointer-events-none absolute bottom-6 left-1/2 z-[17] -translate-x-1/2">
-      <button
-        type="button"
-        onClick={onPress}
-        className="pointer-events-auto inline-flex cursor-pointer items-center gap-1 rounded-full border-3 border-primary bg-white px-3 py-2 text-label-m-emphasis mobile:text-label-s-emphasis font-semibold text-dark-gray shadow-md transition hover:bg-gray-50"
-      >
-        <RefreshCw
-          className="h-4 w-4 shrink-0 text-primary"
-          strokeWidth={2.2}
-          aria-hidden
-        />
-        현 위치에서 검색
-      </button>
-    </div>
+    <button
+      type="button"
+      onClick={onPress}
+      className={cn(searchHerePillClass, "cursor-pointer transition hover:bg-gray-50")}
+    >
+      <RefreshCw
+        className="h-4 w-4 shrink-0 text-primary"
+        strokeWidth={2.2}
+        aria-hidden
+      />
+      {label}
+    </button>
   );
 }
diff --git a/src/components/map/useMapPlaceSearch.test.tsx b/src/components/map/useMapPlaceSearch.test.tsx
index 0eb27186..fd2ccb51 100644
--- a/src/components/map/useMapPlaceSearch.test.tsx
+++ b/src/components/map/useMapPlaceSearch.test.tsx
@@ -12,8 +12,10 @@ import { registerQueryClient } from "@/lib/query-client";
 import { placeDetailQueryKey } from "@/lib/places/place-queries";
 import { useMapPinsFocusStore } from "@/stores/map-pins-focus-store";
 import { useSessionStore } from "@/stores/session-store";
+import { useSearchRecenterStore } from "@/stores/search-recenter-store";
 const network = vi.hoisted(() => ({
   page: vi.fn(),
+  area: vi.fn(),
   detail: vi.fn(),
   select: vi.fn(),
   track: vi.fn(),
@@ -22,6 +24,7 @@ const network = vi.hoisted(() => ({
 }));
 vi.mock("@/hooks/usePlacesSearch", () => ({
   fetchPlacesPageWithPhotos: network.page,
+  fetchPlacesAreaPage: network.area,
 }));
 vi.mock("@/lib/api/client", () => ({ apiFetch: vi.fn() }));
 vi.mock("@/contexts/SelectedPlaceContext", () => ({
@@ -70,6 +73,7 @@ beforeEach(async () => {
     if (String(url).endsWith("/places/resolve")) return Response.json({ detail: rawDetail, source: "GOOGLE", cacheStatus: "MISS", googleDetailsRequested: true, termination: "SUCCEEDED" });
     throw new Error(`Unexpected HTTP ${String(url)}`);
   });
+  network.area.mockReset().mockResolvedValue({ items: [], nextPageToken: null });
   network.page.mockReset().mockResolvedValue({
     items: [
       {
@@ -95,7 +99,7 @@ beforeEach(async () => {
   network.track.mockReset();
   useSessionStore.setState({ currentRoomId: "room" });
   usePlaceSearchStore.getState().clear();
-  useMapCenterStore.setState({ mapCenter: { lat: 1, lng: 2 }, zoom: 12 });
+  useMapCenterStore.setState({ mapCenter: { lat: 1, lng: 2 }, zoom: 12, radiusMeters: null, bounds: null });
   host = document.createElement("div");
   root = createRoot(host);
   await act(async () => root.render(<Harness />));
@@ -110,9 +114,11 @@ it("web whole search publishes only Text Search pins without selecting a detail
   expect(usePlaceSearchStore.getState().selectedId).toBeNull();
   expect(usePlaceSearchStore.getState().items.map(x => x.googlePlaceId)).toEqual(["other"]);
   expect(usePlaceSearchStore.getState().items[0].rating).toBe(4.2);
-  expect(client.getQueryData(placeDetailQueryKey("first"))).toEqual(rawDetail);
+  expect(network.page).toHaveBeenCalledWith(expect.objectContaining({ latitude: 1, longitude: 2, radius: 5000 }));
+  expect(vi.mocked(apiFetch).mock.calls.filter(([url]) => String(url).endsWith("/places/resolve"))).toHaveLength(0);
+  expect(client.getQueryData(placeDetailQueryKey("first"))).toBeUndefined();
 });
-it("mobile whole search keeps cards collapsed and reuses resolved full detail without GET supplement", async () => {
+it("mobile whole search keeps cards collapsed without detail requests", async () => {
   await act(async () => root.render(<Harness mobile />));
   await act(async () => {
     await api.confirm(confirmation());
@@ -139,6 +145,40 @@ it("mobile specific reuses chosen resolved detail without Text Search", async ()
     expect.objectContaining({ analyticsSource: "search", itinerarySource: "search" }),
   );
 });
+// 센소지를 찾은 뒤 지도를 옮겨 재검색할 때 위치 우선(bias)으로 찾으면 Google이 센소지를 다시 돌려줬다
+it.each([
+  ["shows what Google finds inside the visible map", ["inside"]],
+  ["shows no results when Google finds nothing inside the visible map", []],
+] as const)("search here asks Google for the visible map only and %s", async (_, expected) => {
+  await act(async () => { await api.confirm(confirmation()); });
+  const bounds = { south: 0, west: 1, north: 2, east: 3 };
+  useMapCenterStore.setState({ mapCenter: { lat: 1, lng: 2 }, zoom: 15, radiusMeters: 1234, bounds });
+  const inside = { googlePlaceId: "inside", name: "화면 안", location: { lat: 1.5, lng: 2.5 } };
+  network.area.mockResolvedValueOnce({ items: expected.length ? [inside] : [], nextPageToken: null });
+  await act(async () => useSearchRecenterStore.getState().requestSearchRecenter());
+  await vi.waitFor(() => expect(usePlaceSearchStore.getState().status).toBe("done"));
+  expect(usePlaceSearchStore.getState().items.map((x) => x.googlePlaceId)).toEqual(expected);
+  expect(network.area).toHaveBeenCalledExactlyOnceWith({ query: "원래 검색어", area: bounds, pageSize: expect.any(Number) });
+  expect(network.page).toHaveBeenCalledTimes(1);
+});
+it("search box failure shows one message instead of the raw error", async () => {
+  network.page.mockRejectedValueOnce(new TypeError("Failed to fetch"));
+  await act(async () => { await api.confirm(confirmation()); });
+  expect(usePlaceSearchStore.getState()).toMatchObject({ status: "error", error: "검색에 실패했어요.", searchMode: "text" });
+});
+// 「현 위치에서 검색」 실패는 검색창 문구 없이 그 버튼이 「다시 시도」로 알리고, 보이던 결과는 그대로 둔다
+it("search here failure keeps the shown results and leaves the message to the button", async () => {
+  await act(async () => { await api.confirm(confirmation()); });
+  useMapCenterStore.setState({
+    mapCenter: { lat: 1, lng: 2 }, zoom: 15, radiusMeters: 1234,
+    bounds: { south: 0, west: 1, north: 2, east: 3 },
+  });
+  network.area.mockRejectedValueOnce(new TypeError("Failed to fetch"));
+  await act(async () => useSearchRecenterStore.getState().requestSearchRecenter());
+  await vi.waitFor(() => expect(usePlaceSearchStore.getState().status).toBe("error"));
+  expect(usePlaceSearchStore.getState()).toMatchObject({ searchMode: "map_recenter", error: null });
+  expect(usePlaceSearchStore.getState().items.map((x) => x.googlePlaceId)).toEqual(["other"]);
+});
 it("editing input suppresses a late response and analytics", async () => {
   let finish!: (v: unknown) => void;
   network.page.mockReturnValue(
diff --git a/src/components/map/useMapPlaceSearch.ts b/src/components/map/useMapPlaceSearch.ts
index 85b22916..98875cc6 100644
--- a/src/components/map/useMapPlaceSearch.ts
+++ b/src/components/map/useMapPlaceSearch.ts
@@ -4,6 +4,7 @@ import { useEffect, useEffectEvent, useRef, useState } from "react";
 import { useSelectedPlace } from "@/contexts/SelectedPlaceContext";
 import { useSessionUser } from "@/hooks/useSessionUser";
 import {
+  fetchPlacesAreaPage,
   fetchPlacesPageWithPhotos,
   type PlaceSearchResult,
 } from "@/hooks/usePlacesSearch";
@@ -21,6 +22,7 @@ import { AnalyticsEvents, trackAnalyticsEvent } from "@/lib/analytics/track";
 import { getQueryClient } from "@/lib/query-client";
 import { placeDetailQueryKey } from "@/lib/places/place-queries";
 import { PLACES_SEARCH_PAGE_SIZE } from "@/lib/places/placesSearchPageSize";
+import { clampPlacesSearchRadiusMeters } from "@/lib/places/placesSearchRadius";
 import {
   confirmPlaceSearch,
   type ResolvedSearchAnchor,
@@ -32,10 +34,15 @@ import {
   useMapPinsFocusStore,
 } from "@/stores/map-pins-focus-store";
 import { useMobileMapSearchStore } from "@/stores/mobile-map-search-store";
-import { usePlaceSearchStore } from "@/stores/place-search-store";
+import {
+  usePlaceSearchStore,
+  type PlaceSearchMode,
+} from "@/stores/place-search-store";
 import { useSearchRecenterStore } from "@/stores/search-recenter-store";
 import { useSessionStore } from "@/stores/session-store";
 
+const SEARCH_BIAS_RADIUS_METERS = 5000;
+
 export function useMapPlaceSearch(mobile: boolean) {
   const roomId = useSessionStore((s) => s.currentRoomId);
   const userId = useSessionUser().data?.id;
@@ -102,7 +109,7 @@ export function useMapPlaceSearch(mobile: boolean) {
   function applySearchResult(
     result: NonNullable<Awaited<ReturnType<typeof confirmPlaceSearch<PlaceSearchResult>>>>,
     confirmation: SearchConfirmation,
-    mode: "text" | "map_recenter",
+    mode: PlaceSearchMode,
   ) {
     const searchRankBuckets: Record<string, SearchRankBucket> =
       confirmation.kind === "whole"
@@ -126,7 +133,6 @@ export function useMapPlaceSearch(mobile: boolean) {
       searchRankBuckets,
       selectedId,
       status: "done",
-      fallback: result.fallback,
       termination: result.termination,
     });
     setActiveSearchMapPins(placeSearchResultsToMapPins(items));
@@ -155,7 +161,7 @@ export function useMapPlaceSearch(mobile: boolean) {
 
   async function confirm(
     confirmation: SearchConfirmation,
-    mode: "text" | "map_recenter" = "text",
+    mode: PlaceSearchMode = "text",
   ): Promise<boolean> {
     const query = confirmation.query.trim();
     if (!query) return false;
@@ -167,10 +173,14 @@ export function useMapPlaceSearch(mobile: boolean) {
       usePlaceSearchStore.getState().scope === scopeKey &&
       useSessionStore.getState().currentRoomId === roomId &&
       searchPinWriteStillValid(epoch);
-    const mapCenter = useMapCenterStore.getState().mapCenter;
+    const { mapCenter, radiusMeters, bounds } = useMapCenterStore.getState();
+    // 「현 위치에서 검색」은 Google에 지금 화면 사각형 안만 찾게 한다(locationRestriction).
+    // 위치 우선(locationBias)으로 찾으면 화면 밖 결과가 섞여 이동 전 장소로 지도가 되돌아간다.
+    const searchArea = mode === "map_recenter" ? bounds : null;
     usePlaceSearchStore.setState({
       query,
       confirmationKind: confirmation.kind,
+      searchMode: mode,
       status: "pending",
       error: null,
       expanded: false,
@@ -186,6 +196,10 @@ export function useMapPlaceSearch(mobile: boolean) {
       const result = await confirmPlaceSearch({
         ...confirmation,
         mapCenter,
+        // 화면 검색의 반경은 버튼이 다시 뜨는 이동 거리 기준(searchSnapshot)으로만 쓴다
+        radius: searchArea
+          ? clampPlacesSearchRadiusMeters(radiusMeters ?? SEARCH_BIAS_RADIUS_METERS)
+          : SEARCH_BIAS_RADIUS_METERS,
         isCurrent,
         onResolved: (resolved) => {
           usePlaceSearchStore.setState({
@@ -204,11 +218,17 @@ export function useMapPlaceSearch(mobile: boolean) {
             zoom: useMapCenterStore.getState().zoom,
             radius: params.radius,
           });
-          const page = await fetchPlacesPageWithPhotos({
-            ...params,
-            pageSize: PLACES_SEARCH_PAGE_SIZE,
-            pageToken: undefined,
-          });
+          const page = searchArea
+            ? await fetchPlacesAreaPage({
+                query: params.query,
+                area: searchArea,
+                pageSize: PLACES_SEARCH_PAGE_SIZE,
+              })
+            : await fetchPlacesPageWithPhotos({
+                ...params,
+                pageSize: PLACES_SEARCH_PAGE_SIZE,
+                pageToken: undefined,
+              });
           return page.items;
         },
       });
@@ -220,10 +240,7 @@ export function useMapPlaceSearch(mobile: boolean) {
       usePlaceSearchStore.setState({
         status: "error",
         termination: failedTermination(confirmation),
-        error:
-          error instanceof Error
-            ? error.message
-            : "검색에 실패했어요. 다시 시도해주세요.",
+        error: searchFailureMessage(confirmation, mode, error),
       });
       return false;
     }
@@ -275,6 +292,18 @@ function toAnchor(
   };
 }
 
+// 「현 위치에서 검색」 실패는 그 버튼이 「다시 시도」로 알리므로 검색창 문구가 없다.
+// 모두검색 실패의 원문(네트워크 오류면 "Failed to fetch")은 사용자에게 뜻이 없어 한 문구로 보여 준다
+function searchFailureMessage(
+  confirmation: SearchConfirmation,
+  mode: PlaceSearchMode,
+  error: unknown,
+) {
+  if (mode === "map_recenter") return null;
+  if (confirmation.kind === "whole") return "검색에 실패했어요.";
+  return error instanceof Error ? error.message : "검색에 실패했어요. 다시 시도해주세요.";
+}
+
 function failedTermination(confirmation: SearchConfirmation) {
   const termination = usePlaceSearchStore.getState().termination;
   if (termination === "SUCCEEDED" || termination === "NOT_TERMINATED") return termination;
diff --git a/src/components/map/usePlacesSearchHereVisible.ts b/src/components/map/usePlacesSearchHereVisible.ts
index b57ea784..7bafd5c0 100644
--- a/src/components/map/usePlacesSearchHereVisible.ts
+++ b/src/components/map/usePlacesSearchHereVisible.ts
@@ -2,20 +2,38 @@
 
 import { shouldSuggestPlacesSearchRecenter } from "@/lib/maps";
 import { useMapCenterStore } from "@/stores/map-center-store";
+import { usePlaceSearchStore } from "@/stores/place-search-store";
 import type { DiscoverMapSnapshot } from "@/stores/search-recenter-store";
 import { useSearchRecenterStore } from "@/stores/search-recenter-store";
 import type { MapCenterCoords } from "@/stores/map-center-store";
 
 type UsePlacesSearchHereVisibleParams = {
   discoverCategoryId: string | null;
+  /** 카테고리 검색(MapDiscoverPlaces)이 실패함 */
+  discoverFailed: boolean;
 };
 
+/** 「현 위치에서 검색」 결과를 버튼 자리에서 알린다: 실패는 「다시 시도」, 결과 0개는 「검색 결과가 없어요」 */
+export type SearchRecenterNotice = "failed" | "empty";
+
 export type PlacesSearchHereVisibility = {
   visible: boolean;
   suggestSearchRecenter: boolean;
+  searchRecenterNotice: SearchRecenterNotice | null;
   suggestDiscoverRecenter: boolean;
+  /** 실패한 카테고리 검색을 같은 화면에서 다시 시도 */
+  retryDiscoverRecenter: boolean;
 };
 
+function searchRecenterNoticeOf(
+  status: "idle" | "pending" | "done" | "error",
+  hasResults: boolean,
+): SearchRecenterNotice | null {
+  if (status === "error") return "failed";
+  if (status === "done" && !hasResults) return "empty";
+  return null;
+}
+
 function chipsDiscoverRecenterEligible(
   discoverCategoryId: string | null,
   discoverSnapshot: DiscoverMapSnapshot | null,
@@ -45,21 +63,27 @@ function chipsDiscoverRecenterEligible(
  */
 export function usePlacesSearchHereVisible({
   discoverCategoryId,
+  discoverFailed,
 }: UsePlacesSearchHereVisibleParams): PlacesSearchHereVisibility {
   const mapCenter = useMapCenterStore((s) => s.mapCenter);
   const zoom = useMapCenterStore((s) => s.zoom);
   const searchSnapshot = useSearchRecenterStore((s) => s.searchSnapshot);
   const discoverSnapshot = useSearchRecenterStore((s) => s.discoverSnapshot);
+  const searchMode = usePlaceSearchStore((s) => s.searchMode);
+  const searchStatus = usePlaceSearchStore((s) => s.status);
+  const hasResults = usePlaceSearchStore((s) => s.items.length > 0);
 
   if (!mapCenter) {
     return {
       visible: false,
       suggestSearchRecenter: false,
+      searchRecenterNotice: null,
       suggestDiscoverRecenter: false,
+      retryDiscoverRecenter: false,
     };
   }
 
-  const suggestSearchRecenter =
+  const movedFromSearch =
     searchSnapshot != null
     && shouldSuggestPlacesSearchRecenter({
       mapCenter,
@@ -68,17 +92,30 @@ export function usePlacesSearchHereVisible({
       zoom,
       snapshotZoom: searchSnapshot.zoom,
     });
+  // 실패·결과 없음은 검색한 그 화면에서만 알린다. 지도를 옮기면 새 화면 검색이라 「현 위치에서 검색」으로 돌아간다
+  const searchRecenterNotice =
+    movedFromSearch || searchMode !== "map_recenter"
+      ? null
+      : searchRecenterNoticeOf(searchStatus, hasResults);
+  const suggestSearchRecenter =
+    movedFromSearch || searchRecenterNotice === "failed";
 
-  const suggestDiscoverRecenter = chipsDiscoverRecenterEligible(
+  const movedFromDiscover = chipsDiscoverRecenterEligible(
     discoverCategoryId,
     discoverSnapshot,
     mapCenter,
     zoom,
   );
+  // 카테고리 검색이 실패하면 그 화면에서 「다시 시도」, 지도를 옮기면 새 화면 검색이라 「현 위치에서 검색」
+  const retryDiscoverRecenter =
+    discoverFailed && discoverSnapshot != null && !movedFromDiscover;
+  const suggestDiscoverRecenter = movedFromDiscover || retryDiscoverRecenter;
 
   return {
     visible: suggestSearchRecenter || suggestDiscoverRecenter,
     suggestSearchRecenter,
+    searchRecenterNotice,
     suggestDiscoverRecenter,
+    retryDiscoverRecenter,
   };
 }
diff --git a/src/components/search/MapPlaceSearchInput.test.tsx b/src/components/search/MapPlaceSearchInput.test.tsx
index 1e7c4a23..525c6084 100644
--- a/src/components/search/MapPlaceSearchInput.test.tsx
+++ b/src/components/search/MapPlaceSearchInput.test.tsx
@@ -69,7 +69,7 @@ async function key(key: string) {
       .dispatchEvent(new KeyboardEvent("keydown", { key, bubbles: true })),
   );
 }
-it("puts all results first; unselected Enter retains original query and first prediction", async () => {
+it("puts all results first; unselected Enter confirms the original query without a prediction", async () => {
   await type("원래");
   await wait();
   expect(host.querySelector('[role="option"]')?.textContent).toContain(
@@ -77,7 +77,7 @@ it("puts all results first; unselected Enter retains original query and first pr
   );
   await key("Enter");
   expect(confirm).toHaveBeenCalledWith(
-    expect.objectContaining({ query: "원래", kind: "whole", prediction: p }),
+    expect.objectContaining({ query: "원래", kind: "whole", prediction: undefined, session: null }),
   );
 });
 it("arrow-selected recommendation Enter confirms only that prediction", async () => {
@@ -167,6 +167,14 @@ it("429 respects shared wait without request loop on further input", async () =>
   expect(sdk.fetch).toHaveBeenCalledTimes(1);
   expect(host.textContent).toContain("잠시 후");
 });
+it("network failure shows the default notice under all results instead of the raw error", async () => {
+  sdk.fetch.mockRejectedValue(new TypeError("Failed to fetch"));
+  await type("원래"); await wait();
+  expect([...host.querySelectorAll('[role="option"]')].map((option) => option.textContent))
+    .toEqual(["'원래' 모든 결과보기"]);
+  expect(host.textContent).toContain("검색 추천을 불러오지 못했어요. 다시 입력해주세요.");
+  expect(host.textContent).not.toContain("Failed to fetch");
+});
 it("nullable structured main text falls back to actual complete prediction text", async () => {
   await act(async () => vi.advanceTimersByTimeAsync(61000));
   sdk.fetch.mockImplementation(async url => String(url).endsWith("/places/sessions")
diff --git a/src/components/search/MapPlaceSearchInput.tsx b/src/components/search/MapPlaceSearchInput.tsx
index 8604e6b8..b4704f0c 100644
--- a/src/components/search/MapPlaceSearchInput.tsx
+++ b/src/components/search/MapPlaceSearchInput.tsx
@@ -13,7 +13,7 @@ import { MapSearchIcon } from "@/components/map/MapSearchIcon";
 import { SearchIcon } from "@/assets/icons";
 import { SearchBar, SearchBarBack, SearchBarClear, SearchBarIcon, SearchBarInput } from "@/components/ui/search-bar";
 import { AutocompleteSearchSession, MAP_AUTOCOMPLETE_DEBOUNCE_MS } from "@/lib/places/autocomplete-session";
-import type { PlacePrediction, PlaceSession, PredictionText } from "@/lib/api/place-sessions";
+import { PlaceSessionError, type PlacePrediction, type PlaceSession, type PredictionText } from "@/lib/api/place-sessions";
 import type { SearchConfirmation } from "@/lib/places/search-session";
 import { useMapCenterStore } from "@/stores/map-center-store";
 import { cn } from "@/lib/utils";
@@ -145,7 +145,8 @@ export function MapPlaceSearchInput({
           if (requestGeneration === generation.current) {
             flow.abandon();
             token.current = null;
-            setSuggestions({ query, items: [], session: null, status: "error", error: error instanceof Error ? error.message : undefined });
+            // 서버가 준 안내(429 등)는 그대로, 네트워크 오류 원문("Failed to fetch")은 뜻이 없어 기본 안내로 보여 준다
+            setSuggestions({ query, items: [], session: null, status: "error", error: error instanceof PlaceSessionError ? error.message : undefined });
           }
         },
       );
@@ -182,13 +183,14 @@ export function MapPlaceSearchInput({
       suggestions?.query === value && suggestions.status === "done"
         ? suggestions
         : null;
-    const prediction = index > 0 ? ready?.items[index - 1] : ready?.items[0];
+    // 모두검색(index ≤ 0)은 후보를 확정하지 않고 지도 중심에서 찾는다(confirmPlaceSearch)
+    const prediction = index > 0 ? ready?.items[index - 1] : undefined;
     if (index > 0 && !prediction) return;
-    if (ready?.session && ready.session.expiresAt <= Date.now()) {
+    const requestSession = prediction ? ready?.session ?? null : null;
+    if (requestSession && requestSession.expiresAt <= Date.now()) {
       token.current?.abandon(); token.current = null;
       schedule(value); return;
     }
-    const requestSession = ready?.session ?? null;
     cancel();
     const requestGeneration = generation.current;
     confirmGeneration.current = requestGeneration;
diff --git a/src/hooks/useDebouncedPlacePredictions.test.tsx b/src/hooks/useDebouncedPlacePredictions.test.tsx
new file mode 100644
index 00000000..d337fee4
--- /dev/null
+++ b/src/hooks/useDebouncedPlacePredictions.test.tsx
@@ -0,0 +1,85 @@
+// @vitest-environment jsdom
+import { act, useEffect } from "react";
+import { createRoot, type Root } from "react-dom/client";
+import { afterEach, beforeEach, expect, it, vi } from "vitest";
+import { useDebouncedPlacePredictions } from "./useDebouncedPlacePredictions";
+
+const sdk = vi.hoisted(() => ({ fetch: vi.fn() }));
+vi.mock("@/lib/placesAutocompleteSuggest", () => ({
+  AUTOCOMPLETE_SUGGEST_DEBOUNCE_MS: 250,
+  fetchPlacePredictionsForRequest: sdk.fetch,
+  newAutocompleteSessionToken: () => ({}),
+}));
+
+type Hook = ReturnType<typeof useDebouncedPlacePredictions>;
+const buildRequest = (input: string) => ({ input }) as google.maps.places.AutocompleteRequest;
+let api: Hook, root: Root, host: HTMLDivElement;
+function Harness() {
+  const hook = useDebouncedPlacePredictions({ placesLibReady: true, minInputLength: 2, buildRequest });
+  useEffect(() => {
+    api = hook;
+  });
+  return null;
+}
+function deferred() {
+  let resolve!: (list: unknown[]) => void;
+  const promise = new Promise<unknown[]>((r) => { resolve = r; });
+  return { promise, resolve };
+}
+const prediction = (text: string) => ({ placeId: text }) as unknown as google.maps.places.PlacePrediction;
+
+beforeEach(async () => {
+  Object.assign(globalThis, { IS_REACT_ACT_ENVIRONMENT: true });
+  vi.useFakeTimers();
+  sdk.fetch.mockReset();
+  host = document.createElement("div");
+  root = createRoot(host);
+  await act(async () => root.render(<Harness />));
+});
+afterEach(async () => {
+  await act(async () => root.unmount());
+  vi.useRealTimers();
+});
+
+// 예: '도쿄' 요청이 가는 중에 Enter로 검색하면, 늦게 온 '도쿄' 추천이 검색 뒤에 목록을 다시 열었다
+it("a response that arrives after the list is closed does not reopen it", async () => {
+  const first = deferred();
+  sdk.fetch.mockReturnValueOnce(first.promise);
+  await act(async () => api.scheduleFetch("도쿄"));
+  await act(async () => vi.advanceTimersByTimeAsync(250));
+  await act(async () => api.clearSuggestionUi());
+  await act(async () => first.resolve([prediction("도쿄")]));
+  expect(api.isOpen).toBe(false);
+  expect(api.predictions).toEqual([]);
+});
+
+it("a response that arrives after the input got too short does not reopen the list", async () => {
+  const first = deferred();
+  sdk.fetch.mockReturnValueOnce(first.promise);
+  await act(async () => api.scheduleFetch("도쿄"));
+  await act(async () => vi.advanceTimersByTimeAsync(250));
+  await act(async () => api.scheduleFetch("도"));
+  await act(async () => first.resolve([prediction("도쿄")]));
+  expect(api.isOpen).toBe(false);
+});
+
+it("typing again ignores the previous response and shows only the new one", async () => {
+  const first = deferred();
+  sdk.fetch.mockReturnValueOnce(first.promise).mockResolvedValueOnce([prediction("도쿄타워")]);
+  await act(async () => api.scheduleFetch("도쿄"));
+  await act(async () => vi.advanceTimersByTimeAsync(250));
+  await act(async () => api.scheduleFetch("도쿄타"));
+  await act(async () => first.resolve([prediction("도쿄")]));
+  expect(api.isOpen).toBe(false);
+  await act(async () => vi.advanceTimersByTimeAsync(250));
+  expect(api.predictions.map((p) => p.placeId)).toEqual(["도쿄타워"]);
+  expect(api.isOpen).toBe(true);
+});
+
+it("closing before the debounce fires sends no request", async () => {
+  await act(async () => api.scheduleFetch("도쿄"));
+  await act(async () => root.unmount());
+  await act(async () => vi.advanceTimersByTimeAsync(300));
+  expect(sdk.fetch).not.toHaveBeenCalled();
+  root = createRoot(host);
+});
diff --git a/src/hooks/useDebouncedPlacePredictions.ts b/src/hooks/useDebouncedPlacePredictions.ts
index e2c27b7b..b69f2be9 100644
--- a/src/hooks/useDebouncedPlacePredictions.ts
+++ b/src/hooks/useDebouncedPlacePredictions.ts
@@ -1,6 +1,6 @@
 "use client";
 
-import { useCallback, useRef, useState } from "react";
+import { useCallback, useEffect, useRef, useState } from "react";
 
 import {
   AUTOCOMPLETE_SUGGEST_DEBOUNCE_MS,
@@ -42,23 +42,32 @@ export function useDebouncedPlacePredictions(options: {
     useRef<google.maps.places.AutocompleteSessionToken | null>(null);
   const fetchGenRef = useRef(0);
 
+  // 취소 = 예약한 타이머 취소 + 이미 보낸 요청의 응답 무시(번호 올리기). 취소하는 모든 경로가 이 함수를 거친다
+  const cancelPending = useCallback(() => {
+    if (debounceRef.current) {
+      clearTimeout(debounceRef.current);
+      debounceRef.current = null;
+    }
+    fetchGenRef.current += 1;
+  }, []);
+
+  // 입력 직후 화면이 닫히면 대기 중인 타이머가 Google 자동완성을 한 번 더 보낸다(건별 과금)
+  useEffect(() => cancelPending, [cancelPending]);
+
   const invalidateSession = useCallback(() => {
     sessionTokenRef.current = null;
   }, []);
 
   const clearSuggestionUi = useCallback(() => {
-    if (debounceRef.current) {
-      clearTimeout(debounceRef.current);
-      debounceRef.current = null;
-    }
+    cancelPending();
     setPredictions([]);
     setIsOpen(false);
     setActiveIndex(-1);
-  }, []);
+  }, [cancelPending]);
 
   const scheduleFetch = useCallback(
     (value: string) => {
-      if (debounceRef.current) clearTimeout(debounceRef.current);
+      cancelPending();
 
       if (!value.trim()) {
         sessionTokenRef.current = null;
@@ -74,11 +83,10 @@ export function useDebouncedPlacePredictions(options: {
         return;
       }
 
+      // 번호는 예약할 때 잡는다. 그래야 예약 뒤의 취소(다시 입력·닫기·선택)를 모두 알아챈다
+      const gen = fetchGenRef.current;
       debounceRef.current = setTimeout(() => {
         void (async () => {
-          fetchGenRef.current += 1;
-          const gen = fetchGenRef.current;
-
           if (!sessionTokenRef.current) {
             sessionTokenRef.current = newAutocompleteSessionToken();
           }
@@ -103,7 +111,7 @@ export function useDebouncedPlacePredictions(options: {
         })();
       }, debounceMs);
     },
-    [buildRequest, debounceMs, disabled, minInputLength, placesLibReady],
+    [buildRequest, cancelPending, debounceMs, disabled, minInputLength, placesLibReady],
   );
 
   return {
diff --git a/src/hooks/usePlacesSearch.ts b/src/hooks/usePlacesSearch.ts
index 6aea8de3..6a6c91f3 100644
--- a/src/hooks/usePlacesSearch.ts
+++ b/src/hooks/usePlacesSearch.ts
@@ -5,6 +5,7 @@ import { useCallback, useState } from "react";
 
 import {
   searchPlaces,
+  searchPlacesInArea,
   type PlaceSearchItem,
 } from "@/lib/api/places";
 import type { SearchResultCardProps } from "@/types/place";
@@ -55,6 +56,19 @@ export async function fetchPlacesPageWithPhotos(args: {
   return { items: itemsBase, nextPageToken };
 }
 
+export async function fetchPlacesAreaPage(args: {
+  query: string;
+  area: google.maps.LatLngBoundsLiteral;
+  pageSize: number;
+}): Promise<PlaceSearchPage> {
+  const { items, nextPageToken } = await searchPlacesInArea({
+    query: args.query,
+    ...args.area,
+    pageSize: args.pageSize,
+  });
+  return { items: items.map((item) => mapPlaceSearchItem(item)), nextPageToken };
+}
+
 export function placesSearchQueryKey(
   query: string,
   latitude: number | null,
diff --git a/src/lib/api/places.test.ts b/src/lib/api/places.test.ts
index 152a3039..6f4b7921 100644
--- a/src/lib/api/places.test.ts
+++ b/src/lib/api/places.test.ts
@@ -215,3 +215,22 @@ describe("place preview API requests", () => {
     expect(error).toMatchObject({ status: 502 });
   });
 });
+
+describe("place area search API request", () => {
+  beforeEach(() => {
+    apiFetch.mockReset();
+  });
+
+  it("sends the visible rectangle to the area search endpoint without a center or radius", async () => {
+    const { searchPlacesInArea } = await import("@/lib/api/places");
+    apiFetch.mockResolvedValueOnce({ ok: true, json: async () => ({ items: [], nextPageToken: null }) });
+
+    await searchPlacesInArea({ query: "카페", south: 35.7, west: 139.75, north: 35.72, east: 139.8, pageSize: 20 });
+
+    const requestedUrl = new URL(apiFetch.mock.calls[0]![0] as string);
+    expect(requestedUrl.pathname).toBe("/places/search/area");
+    expect(Object.fromEntries(requestedUrl.searchParams)).toEqual({
+      query: "카페", south: "35.7", west: "139.75", north: "35.72", east: "139.8", pageSize: "20",
+    });
+  });
+});
diff --git a/src/lib/api/places.ts b/src/lib/api/places.ts
index a8d16215..10c4cf44 100644
--- a/src/lib/api/places.ts
+++ b/src/lib/api/places.ts
@@ -160,6 +160,34 @@ export async function searchPlaces(params: {
   return res.json();
 }
 
+/** 사각형(지금 보이는 지도 화면) 안의 장소만 찾는다. 다음 페이지는 같은 사각형으로 요청해야 한다 */
+export async function searchPlacesInArea(params: {
+  query: string;
+  south: number;
+  west: number;
+  north: number;
+  east: number;
+  pageSize?: number;
+  pageToken?: string;
+}): Promise<PlaceSearchPageResponse> {
+  const url = new URL(`${API_BASE}/places/search/area`);
+  url.searchParams.set("query", params.query);
+  url.searchParams.set("south", String(params.south));
+  url.searchParams.set("west", String(params.west));
+  url.searchParams.set("north", String(params.north));
+  url.searchParams.set("east", String(params.east));
+  if (params.pageSize !== undefined) {
+    url.searchParams.set("pageSize", String(params.pageSize));
+  }
+  if (params.pageToken) {
+    url.searchParams.set("pageToken", params.pageToken);
+  }
+
+  const res = await apiFetch(url.toString());
+  if (!res.ok) throw new HttpError(res.status, `Places area search failed: ${res.status}`);
+  return res.json();
+}
+
 export async function requestPlaceDetail(
   googlePlaceId: string,
 ): Promise<PlaceDetail> {
diff --git a/src/lib/map-viewport-commit.test.ts b/src/lib/map-viewport-commit.test.ts
new file mode 100644
index 00000000..463d2d30
--- /dev/null
+++ b/src/lib/map-viewport-commit.test.ts
@@ -0,0 +1,52 @@
+// @vitest-environment jsdom
+import { beforeEach, expect, it } from "vitest";
+import { settleSearchSnapshotAfterMove } from "./map-viewport-commit";
+import { useMapCenterStore } from "@/stores/map-center-store";
+import { useSearchRecenterStore } from "@/stores/search-recenter-store";
+
+const searched = { center: { lat: 0, lng: 0 }, zoom: 10, radius: 5000 };
+
+function fakeMap() {
+  const div = document.createElement("div");
+  const handlers = new Map<string, () => void>();
+  return {
+    div,
+    fire: (name: string) => handlers.get(name)?.(),
+    map: {
+      getDiv: () => div,
+      addListener: (name: string, handler: () => void) => {
+        handlers.set(name, handler);
+        return { remove: () => handlers.delete(name) };
+      },
+    },
+  };
+}
+
+beforeEach(() => {
+  useSearchRecenterStore.setState({ searchSnapshot: searched });
+  useMapCenterStore.setState({ mapCenter: { lat: 1, lng: 2 }, zoom: 14, radiusMeters: 1500 });
+});
+
+// 카페 검색 결과에 맞춰 지도가 확대되면 그 화면이 기준점이라 버튼이 보이지 않는다
+it("takes the settled result camera as the search-here baseline", () => {
+  const { map, fire } = fakeMap();
+  settleSearchSnapshotAfterMove(map);
+  fire("idle");
+  expect(useSearchRecenterStore.getState().searchSnapshot).toEqual({ center: { lat: 1, lng: 2 }, zoom: 14, radius: 1500 });
+});
+
+it.each(["pointerdown", "wheel"])("keeps the searched area when the user %s the map before it settles", (event) => {
+  const { map, div, fire } = fakeMap();
+  settleSearchSnapshotAfterMove(map);
+  div.dispatchEvent(new Event(event));
+  fire("idle");
+  expect(useSearchRecenterStore.getState().searchSnapshot).toEqual(searched);
+});
+
+it("does not restore a search the user already cleared", () => {
+  const { map, fire } = fakeMap();
+  settleSearchSnapshotAfterMove(map);
+  useSearchRecenterStore.getState().clearSearchSnapshot();
+  fire("idle");
+  expect(useSearchRecenterStore.getState().searchSnapshot).toBeNull();
+});
diff --git a/src/lib/map-viewport-commit.ts b/src/lib/map-viewport-commit.ts
index cdced274..548a5b30 100644
--- a/src/lib/map-viewport-commit.ts
+++ b/src/lib/map-viewport-commit.ts
@@ -3,9 +3,10 @@
 import { clampPlacesSearchRadiusMeters } from "@/lib/places/placesSearchRadius";
 import { viewportSearchRadiusMetersFromBounds } from "@/lib/maps";
 import { useMapCenterStore } from "@/stores/map-center-store";
-import type {
-  DiscoverMapSnapshot,
-  SearchMapSnapshot,
+import {
+  useSearchRecenterStore,
+  type DiscoverMapSnapshot,
+  type SearchMapSnapshot,
 } from "@/stores/search-recenter-store";
 
 /** 검색 페이지 `GET /places/search` 의 위치 고정 스냅샷 (`map-center-store` 기준) */
@@ -24,6 +25,32 @@ export function buildSearchMapSnapshotFromMapCenterStore(): SearchMapSnapshot |
   };
 }
 
+/**
+ * 검색 결과를 보여 주려고 옮긴 지도가 멈추면 그 화면을 「현 위치에서 검색」 기준점으로 삼는다.
+ * 기준점이 검색 요청 때 화면이면 결과로 옮기자마자(맞춤 확대·첫 결과로 이동) 버튼이 다시 보인다.
+ * 옮길 곳이 지금 화면과 같으면 idle이 오지 않으므로, 그 전에 사용자가 지도를 만지면 취소해
+ * 사용자가 옮긴 화면을 기준점으로 삼지 않는다. +/−는 지도 안 컨트롤이라 함께 잡힌다.
+ */
+export function settleSearchSnapshotAfterMove(
+  map: Pick<google.maps.Map, "getDiv" | "addListener">,
+): () => void {
+  const div = map.getDiv();
+  const cancel = () => {
+    idle.remove();
+    div.removeEventListener("pointerdown", cancel, true);
+    div.removeEventListener("wheel", cancel, true);
+  };
+  const idle = map.addListener("idle", () => {
+    cancel();
+    const camera = buildSearchMapSnapshotFromMapCenterStore();
+    const { searchSnapshot, setSearchSnapshot } = useSearchRecenterStore.getState();
+    if (camera && searchSnapshot) setSearchSnapshot(camera);
+  });
+  div.addEventListener("pointerdown", cancel, true);
+  div.addEventListener("wheel", cancel, { capture: true, passive: true });
+  return cancel;
+}
+
 /** Discover(Places JS) 영역 고정 스냅샷 — 맵 현재 카메라 기준 1회 커밋 */
 export function buildDiscoverSnapshotFromGoogleMap(
   map: google.maps.Map,
diff --git a/src/lib/places/place-detail-cache.test.tsx b/src/lib/places/place-detail-cache.test.tsx
index 5438d7eb..40a8f48d 100644
--- a/src/lib/places/place-detail-cache.test.tsx
+++ b/src/lib/places/place-detail-cache.test.tsx
@@ -53,7 +53,7 @@ it("resolved full raw response seeds canonical cache and later panels reuse it w
   };
   vi.mocked(requestPlaceDetail).mockReset().mockResolvedValue(detail);
   vi.mocked(apiFetch).mockResolvedValue(Response.json({ detail, source: "GOOGLE", cacheStatus: "MISS", googleDetailsRequested: true, termination: "SUCCEEDED" }));
-  await confirmPlaceSearch({ query: "카페", kind: "specific", prediction: { placeId: "one", text: null, structuredFormat: null }, session: { sessionToken: "token", expiresAt: Date.now()+60000 }, mapCenter: null, isCurrent: () => true, search: async () => [] });
+  await confirmPlaceSearch({ query: "카페", kind: "specific", prediction: { placeId: "one", text: null, structuredFormat: null }, session: { sessionToken: "token", expiresAt: Date.now()+60000 }, mapCenter: null, radius: 5000, isCurrent: () => true, search: async () => [] });
   const cached = client.getQueryData(placeDetailQueryKey("one"));
   expect(cached).toEqual(detail);
   expect(await fetchPlaceDetail("places/one")).toBe(cached);
diff --git a/src/lib/places/search-session.test.ts b/src/lib/places/search-session.test.ts
index 34a5b244..cbaf076a 100644
--- a/src/lib/places/search-session.test.ts
+++ b/src/lib/places/search-session.test.ts
@@ -24,18 +24,18 @@ function setup(overrides = {}) {
   return { search, args: { query: "원래 검색어", kind: "whole" as const,
     prediction: { placeId: "first", text: null, structuredFormat: null },
     session: { sessionToken: "server-token", expiresAt: Date.now() + 60000 },
-    mapCenter: { lat: 1, lng: 2 }, isCurrent: () => true, search, ...overrides } };
+    mapCenter: { lat: 1, lng: 2 }, radius: 5000, isCurrent: () => true, search, ...overrides } };
 }
 describe("server session confirmation", () => {
   it("resolves same server token once and seeds full raw detail before publishing anchor", async () => {
-    const { args, search } = setup();
+    const { args, search } = setup({ kind: "specific" });
     const onAnchor = vi.fn(() => expect(client.getQueryData(placeDetailQueryKey("first"))).toEqual(detail));
     const result = await confirmPlaceSearch({ ...args, onAnchor });
     expect(apiFetch).toHaveBeenCalledExactlyOnceWith(expect.stringContaining("/places/resolve"), expect.objectContaining({ method: "POST", body: JSON.stringify({ sessionToken: "server-token", googlePlaceId: "first" }) }));
     expect(result?.anchor?.detail).toEqual(detail);
     expect(result?.termination).toBe("SUCCEEDED");
     expect(onAnchor).toHaveBeenCalledTimes(1);
-    expect(search).toHaveBeenCalledExactlyOnceWith({ query: "원래 검색어", latitude: 37, longitude: 127, radius: 5000 });
+    expect(search).not.toHaveBeenCalled();
   });
   it("frontend cache HIT still resolves; keeps server HIT distinct from termination", async () => {
     client.setQueryData(placeDetailQueryKey("first"), detail);
@@ -51,15 +51,13 @@ describe("server session confirmation", () => {
     expect((await confirmPlaceSearch(args))?.anchor?.detail.rating).toBe(4.5);
     expect(search).not.toHaveBeenCalled();
   });
-  it.each(["absent", "failed", "null coordinates"])("whole uses map-center fallback for %s without another Google call", async mode => {
-    const { args, search } = setup(mode === "absent" ? { prediction: undefined } : {});
-    if (mode === "failed") vi.mocked(apiFetch).mockResolvedValue(Response.json({ code: "EXTERNAL_API_ERROR", message: "실패" }, { status: 502 }));
-    if (mode === "null coordinates") vi.mocked(apiFetch).mockResolvedValue(Response.json({ ...response, detail: { ...detail, location: null } }));
+  // 도쿄 지도에서 '음식점' 첫 후보가 용인의 '음식점' 가게여도 지도 중심에서 찾는다
+  it.each(["with", "without"])("whole searches around the map center %s a first suggestion and never resolves it", async mode => {
+    const { args, search } = setup({ radius: 1234, ...(mode === "without" ? { prediction: undefined } : {}) });
     const result = await confirmPlaceSearch(args);
-    expect(result?.fallback).toBe(true);
-    expect(search).toHaveBeenCalledExactlyOnceWith({ query: "원래 검색어", latitude: 1, longitude: 2, radius: 5000 });
-    expect(apiFetch).toHaveBeenCalledTimes(mode === "absent" ? 0 : 1);
-    if (mode === "null coordinates") expect(result?.termination).toBe("SUCCEEDED");
+    expect(apiFetch).not.toHaveBeenCalled();
+    expect(search).toHaveBeenCalledExactlyOnceWith({ query: "원래 검색어", latitude: 1, longitude: 2, radius: 1234 });
+    expect(result).toMatchObject({ anchor: null, termination: "not-requested" });
   });
   it("specific null coordinates cannot fake location or make supplementary requests", async () => {
     vi.mocked(apiFetch).mockResolvedValue(Response.json({ ...response, detail: { ...detail, location: null } }));
@@ -70,7 +68,7 @@ describe("server session confirmation", () => {
   it("late resolve cannot seed scope cache or publish search", async () => {
     let finish!: (v: Response) => void; let current = true;
     vi.mocked(apiFetch).mockReturnValue(new Promise(r => { finish = r; }));
-    const { args, search } = setup({ isCurrent: () => current });
+    const { args, search } = setup({ kind: "specific", isCurrent: () => current });
     const pending = confirmPlaceSearch(args); current = false; finish(Response.json(response));
     expect(await pending).toBeNull();
     expect(client.getQueryData(placeDetailQueryKey("first"))).toBeUndefined();
diff --git a/src/lib/places/search-session.ts b/src/lib/places/search-session.ts
index f4a30ce9..3ecd88ee 100644
--- a/src/lib/places/search-session.ts
+++ b/src/lib/places/search-session.ts
@@ -48,6 +48,8 @@ export function terminatePredictionSession(
 }
 type ConfirmPlaceSearchArgs<T> = Omit<SearchConfirmation, "generation"> & {
   mapCenter: google.maps.LatLngLiteral | null;
+  /** 모두검색 locationBias 반경(m) */
+  radius: number;
   isCurrent: () => boolean;
   onAnchor?: (anchor: ResolvedSearchAnchor) => void;
   onResolved?: (resolved: PlaceResolveResponse) => void;
@@ -59,47 +61,41 @@ type SearchResolution = {
 };
 async function resolveSearchPrediction<T>(
   args: ConfirmPlaceSearchArgs<T>, prediction: PlacePrediction,
-): Promise<SearchResolution | null> {
-  let anchor: ResolvedSearchAnchor | null = null;
-  let termination: SearchResolution["termination"] = "not-requested";
+): Promise<ResolvedSearchAnchor | null> {
   try {
     const resolved = await terminatePredictionSession(prediction, args.session, args.isCurrent);
     if (!args.isCurrent()) return null;
-    termination = resolved.termination;
     // Seed the complete untouched server DTO BEFORE a detail consumer mounts.
     getQueryClient()?.setQueryData(placeDetailQueryKey(resolved.detail.googlePlaceId), resolved.detail);
     args.onResolved?.(resolved);
     const location = normalizePreviewLocation(resolved.detail.location);
-    if (location && Math.abs(location.lat) <= 90 && Math.abs(location.lng) <= 180)
-      anchor = { ...resolved, googlePlaceId: resolved.detail.googlePlaceId, location };
-    else if (args.kind === "specific") throw new Error("장소 좌표를 확인할 수 없어요.");
+    if (!location || Math.abs(location.lat) > 90 || Math.abs(location.lng) > 180)
+      throw new Error("장소 좌표를 확인할 수 없어요.");
+    return { ...resolved, googlePlaceId: resolved.detail.googlePlaceId, location };
   } catch (error) {
-    // Coordinate absence does not erase a verified server termination.
-    if (termination === "not-requested") termination = "failed";
-    if (args.kind === "specific" && args.isCurrent()) throw error;
+    if (args.isCurrent()) throw error;
+    return null;
   }
-  return { anchor, termination };
 }
 export async function confirmPlaceSearch<T>(args: ConfirmPlaceSearchArgs<T>): Promise<
-  SearchResolution & { items: T[]; fallback: boolean } | null
+  SearchResolution & { items: T[] } | null
 > {
   const query = args.query.trim();
   if (!query) throw new Error("검색어를 입력해주세요.");
   if (!args.isCurrent()) return null;
-  const resolution = args.prediction
-    ? await resolveSearchPrediction(args, args.prediction)
-    : { anchor: null, termination: "not-requested" as const };
-  if (!resolution) return null;
-  const { anchor, termination } = resolution;
-  if (!args.isCurrent()) return null;
-  if (anchor) args.onAnchor?.(anchor);
   if (args.kind === "specific") {
-    if (!anchor) throw new Error("장소 정보를 확인할 수 없어요.");
-    return { anchor, items: [], fallback: false, termination };
+    if (!args.prediction) throw new Error("장소 정보를 확인할 수 없어요.");
+    const anchor = await resolveSearchPrediction(args, args.prediction);
+    if (!anchor || !args.isCurrent()) return null;
+    args.onAnchor?.(anchor);
+    return { anchor, items: [], termination: anchor.termination };
   }
-  const center = anchor?.location ?? args.mapCenter;
+  // 모두검색은 자동완성 첫 후보가 아니라 보고 있는 지도 중심에서 찾는다.
+  // 첫 후보는 이름만 같은 다른 나라 장소일 수 있다(도쿄 지도에서 '음식점' → 용인의 '음식점' 가게).
+  // 검색어에 지명이 있으면 Google이 locationBias를 무시하므로 서울 지도에서 '라스베가스'도 찾는다.
+  const center = args.mapCenter;
   if (!center) throw new Error("지도 위치를 확인한 뒤 다시 검색해주세요.");
-  const items = await args.search({ query, latitude: center.lat, longitude: center.lng, radius: 5000 });
+  const items = await args.search({ query, latitude: center.lat, longitude: center.lng, radius: args.radius });
   if (!args.isCurrent()) return null;
-  return { anchor, items, fallback: !anchor, termination };
+  return { anchor: null, items, termination: "not-requested" };
 }
diff --git a/src/stores/map-center-store.ts b/src/stores/map-center-store.ts
index 750f025f..92265c89 100644
--- a/src/stores/map-center-store.ts
+++ b/src/stores/map-center-store.ts
@@ -7,11 +7,14 @@ type MapCenterState = {
   zoom: number | null;
   /** 현재 뷰포트 기준 대략 반경(m): 중심 ↔ bounds 북동 코너 */
   radiusMeters: number | null;
+  /** 현재 뷰포트 경계 — 「현 위치에서 검색」 결과를 화면 안으로 거른다 */
+  bounds: google.maps.LatLngBoundsLiteral | null;
   setMapCenter: (center: MapCenterCoords) => void;
   setMapCamera: (payload: {
     mapCenter: MapCenterCoords;
     zoom: number;
     radiusMeters: number;
+    bounds: google.maps.LatLngBoundsLiteral | null;
   }) => void;
 };
 
@@ -19,7 +22,8 @@ export const useMapCenterStore = create<MapCenterState>((set) => ({
   mapCenter: null,
   zoom: null,
   radiusMeters: null,
+  bounds: null,
   setMapCenter: (mapCenter) => set({ mapCenter }),
-  setMapCamera: ({ mapCenter, zoom, radiusMeters }) =>
-    set({ mapCenter, zoom, radiusMeters }),
+  setMapCamera: ({ mapCenter, zoom, radiusMeters, bounds }) =>
+    set({ mapCenter, zoom, radiusMeters, bounds }),
 }));
diff --git a/src/stores/place-search-store.ts b/src/stores/place-search-store.ts
index 96126b1a..94dccb8f 100644
--- a/src/stores/place-search-store.ts
+++ b/src/stores/place-search-store.ts
@@ -3,11 +3,16 @@ import type { PlaceResolveResponse } from "@/lib/api/place-sessions";
 import type { SearchRankBucket } from "@/lib/analytics/context";
 import type { PlaceSearchResult } from "@/hooks/usePlacesSearch";
 
+/** 검색창에서 찾기(text) / 「현 위치에서 검색」 버튼(map_recenter) */
+export type PlaceSearchMode = "text" | "map_recenter";
+
 type PlaceSearchState = {
   scope: string;
   generation: number;
   query: string;
   confirmationKind: "whole" | "specific" | null;
+  /** 이 검색을 시작한 곳. 「현 위치에서 검색」의 실패·결과 없음은 검색창이 아니라 그 버튼 자리에서 알린다 */
+  searchMode: PlaceSearchMode;
   items: PlaceSearchResult[];
   /** Coarse original Text Search rank, independent of retained recommendation/display order. */
   searchRankBuckets: Readonly<Record<string, SearchRankBucket>>;
@@ -15,7 +20,6 @@ type PlaceSearchState = {
   expanded: boolean;
   status: "idle" | "pending" | "done" | "error";
   error: string | null;
-  fallback: boolean;
   termination: PlaceResolveResponse["termination"] | "failed" | "not-requested";
   resolution: Omit<PlaceResolveResponse, "detail"> | null;
   setScope: (scope: string) => void;
@@ -27,13 +31,13 @@ type PlaceSearchState = {
 const empty = {
   query: "",
   confirmationKind: null,
+  searchMode: "text" as const,
   items: [],
   searchRankBuckets: {},
   selectedId: null,
   expanded: false,
   status: "idle" as const,
   error: null,
-  fallback: false,
   termination: "not-requested" as const,
   resolution: null,
 };