diff --git a/alembic/versions/f7a8b9c0d1e2_add_seen_decision_and_price.py b/alembic/versions/f7a8b9c0d1e2_add_seen_decision_and_price.py
new file mode 100644
index 0000000..28abb56
--- /dev/null
+++ b/alembic/versions/f7a8b9c0d1e2_add_seen_decision_and_price.py
@@ -0,0 +1,33 @@
+"""add seen decision and price_at_decision
+
+Revision ID: f7a8b9c0d1e2
+Revises: d6e7f8a9b0c1
+Create Date: 2026-05-16 00:00:00.000000
+
+Adds support for the soft-hide "seen" decision type. The decision column is
+already a free string, so no schema change is needed for the enum value; we
+only need to add price_at_decision so the client can resurface listings
+whose price has changed since the user marked them seen.
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision: str = 'f7a8b9c0d1e2'
+down_revision: Union[str, None] = 'd6e7f8a9b0c1'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    op.add_column(
+        'listingdecision',
+        sa.Column('price_at_decision', sa.Float(), nullable=True),
+    )
+
+
+def downgrade() -> None:
+    op.drop_column('listingdecision', 'price_at_decision')
diff --git a/api/decision_routes.py b/api/decision_routes.py
index db902d3..8d168ad 100644
--- a/api/decision_routes.py
+++ b/api/decision_routes.py
@@ -17,14 +17,20 @@ decision_router = APIRouter(prefix="/api/decisions", tags=["decisions"])
 
 
 class SetDecisionRequest(BaseModel):
-    decision: str = Field(description="'liked' or 'disliked'")
+    decision: str = Field(description="'liked', 'disliked', or 'seen'")
     listing_type: str = Field(description="'RENT' or 'BUY'")
+    price_at_decision: float | None = Field(
+        default=None,
+        description="Total price at the time of the decision; used by the client to "
+        "resurface a 'seen' listing whose price has changed since dismissal.",
+    )
 
 
 class DecisionResponse(BaseModel):
     listing_id: int
     listing_type: str
     decision: str
+    price_at_decision: float | None = None
     created_at: str
     updated_at: str
 
@@ -46,6 +52,7 @@ def _to_response(d: decision_service.ListingDecision) -> DecisionResponse:
         listing_id=d.listing_id,
         listing_type=d.listing_type,
         decision=d.decision,
+        price_at_decision=d.price_at_decision,
         created_at=d.created_at.isoformat(),
         updated_at=d.updated_at.isoformat(),
     )
@@ -73,6 +80,7 @@ async def set_decision(
             listing_id=listing_id,
             listing_type=body.listing_type,
             decision=body.decision,
+            price_at_decision=body.price_at_decision,
         )
         timings.append(f"upsert;dur={(time.monotonic() - t0) * 1000:.1f}")
     except ValueError as e:
diff --git a/frontend/src/App.tsx b/frontend/src/App.tsx
index 5a523eb..03eb6dd 100644
--- a/frontend/src/App.tsx
+++ b/frontend/src/App.tsx
@@ -130,7 +130,29 @@ function AppContent() {
   const [bottomSheetSnap, setBottomSheetSnap] = useState<string | number | null>("148px");
 
   // Decision state (like/dislike)
-  const { decide, clear, getDecision, likedCount, isLoaded: isDecisionsLoaded } = useDecisions(user);
+  const { decide, clear, markSeen, getDecision, getDecisionEntry, likedCount, isLoaded: isDecisionsLoaded } = useDecisions(user);
+  // When true, listings marked "seen" with unchanged price are still shown
+  // (with an Unhide affordance) instead of hidden. Off by default.
+  const [showHidden, setShowHidden] = useState(false);
+
+  // After 3 seconds of dwell in the detail sheet, mark the listing as `seen`
+  // (passively hide it from the main list unless its price later changes).
+  // 3s is enough to ignore accidental flick-taps but short enough to be
+  // invisible during real reading. Liked listings are skipped inside markSeen.
+  useEffect(() => {
+    if (selectedListingId === null) return;
+    const id = selectedListingId;
+    const listingType = (queryParameters?.listing_type ?? 'RENT') as 'RENT' | 'BUY';
+    const timer = window.setTimeout(() => {
+      const feature = listingData?.features.find((f) => {
+        const parts = f.properties.url.split('/');
+        return parseInt(parts[parts.length - 1], 10) === id;
+      });
+      const price = feature?.properties.total_price ?? null;
+      void markSeen(id, price, listingType);
+    }, 3000);
+    return () => window.clearTimeout(timer);
+  }, [selectedListingId, listingData, markSeen, queryParameters?.listing_type]);
 
   // Explicit task ID set by fetch-data action (to track as "active")
   const [explicitTaskId, setExplicitTaskId] = useState<string | null>(null);
@@ -379,18 +401,54 @@ function AppContent() {
       });
     }
 
-    // Filter out disliked listings (client-side for instant feedback)
+    // Filter out disliked listings (client-side for instant feedback).
+    // Also hide listings marked "seen" UNLESS:
+    //   - the toggle "Show hidden" is on, OR
+    //   - the listing's current price differs from price_at_decision (any
+    //     change resurfaces it per the user's spec).
     if (isDecisionsLoaded) {
       features = features.filter((f) => {
         const parts = f.properties.url.split('/');
         const id = parseInt(parts[parts.length - 1], 10);
         const type = f.properties.listing_type === 'BUY' ? 'BUY' : 'RENT';
-        return getDecision(id, type) !== 'disliked';
+        const entry = getDecisionEntry(id, type);
+        if (!entry) return true;
+        if (entry.decision === 'disliked') return false;
+        if (entry.decision === 'seen') {
+          if (showHidden) return true;
+          const priceNow = f.properties.total_price;
+          const priceThen = entry.price_at_decision;
+          // Resurface if either price is missing (we can't compare safely) OR
+          // the live price diverges from the snapshot taken at mark-seen time.
+          if (typeof priceNow !== 'number' || typeof priceThen !== 'number') return true;
+          return priceNow !== priceThen;
+        }
+        return true;
       });
     }
 
     return { ...listingData, features };
-  }, [listingData, poiMetricSelection, poiTravelFilters, isDecisionsLoaded, getDecision]);
+  }, [listingData, poiMetricSelection, poiTravelFilters, isDecisionsLoaded, getDecisionEntry, showHidden]);
+
+  // Count of listings that WOULD be hidden by the seen-filter at the current
+  // price (i.e. seen + price unchanged). Drives the "Hidden (N)" toggle —
+  // when 0 we don't surface the toggle at all.
+  const hiddenCount = useMemo(() => {
+    if (!isDecisionsLoaded || !listingData) return 0;
+    let n = 0;
+    for (const f of listingData.features) {
+      const parts = f.properties.url.split('/');
+      const id = parseInt(parts[parts.length - 1], 10);
+      const type = f.properties.listing_type === 'BUY' ? 'BUY' : 'RENT';
+      const entry = getDecisionEntry(id, type);
+      if (entry?.decision !== 'seen') continue;
+      const priceNow = f.properties.total_price;
+      const priceThen = entry.price_at_decision;
+      if (typeof priceNow !== 'number' || typeof priceThen !== 'number') continue;
+      if (priceNow === priceThen) n++;
+    }
+    return n;
+  }, [listingData, isDecisionsLoaded, getDecisionEntry]);
 
   // Compute the effective metric string for the heatmap
   const effectiveMetric = useMemo(() => {
@@ -792,6 +850,9 @@ function AppContent() {
               onTaskCreated={handlePOITaskCreated}
               initialValues={initialFilterValuesRef.current}
               onFormReady={handleFilterBarFormReady}
+              showHidden={showHidden}
+              onToggleShowHidden={() => setShowHidden((v) => !v)}
+              hiddenCount={hiddenCount}
             />
           </div>
 
diff --git a/frontend/src/components/FilterBar.tsx b/frontend/src/components/FilterBar.tsx
index c6bcfed..22599d8 100644
--- a/frontend/src/components/FilterBar.tsx
+++ b/frontend/src/components/FilterBar.tsx
@@ -2,7 +2,7 @@ import { useState, useEffect, useCallback, useRef } from 'react';
 import { useForm } from 'react-hook-form';
 import { zodResolver } from '@hookform/resolvers/zod';
 import { z } from 'zod';
-import { ChevronDown, Loader2, RefreshCw, Search, MapPin, SlidersHorizontal } from 'lucide-react';
+import { ChevronDown, Loader2, RefreshCw, Search, MapPin, SlidersHorizontal, Eye, EyeOff } from 'lucide-react';
 import { Button } from './ui/button';
 import { Input } from './ui/input';
 import { Popover, PopoverContent, PopoverTrigger } from './ui/popover';
@@ -70,6 +70,12 @@ interface FilterBarProps {
   initialValues?: ParameterValues;
   /** Provides parent access to the form handle (e.g. for chip-remove resets). */
   onFormReady?: (handle: FilterBarFormHandle) => void;
+  /** When true, listings marked "seen" with unchanged price are still shown. */
+  showHidden?: boolean;
+  /** Toggles the showHidden flag (re-renders the main list). */
+  onToggleShowHidden?: () => void;
+  /** Count of currently-hidden listings; controls whether the toggle is offered. */
+  hiddenCount?: number;
 }
 
 // ── Helpers ──
@@ -140,6 +146,9 @@ export function FilterBar({
   onTaskCreated,
   initialValues,
   onFormReady,
+  showHidden = false,
+  onToggleShowHidden,
+  hiddenCount = 0,
 }: FilterBarProps) {
   const [selectedFurnishTypes, setSelectedFurnishTypes] = useState<FurnishType[]>(
     initialValues?.furnish_types ?? [],
@@ -711,6 +720,24 @@ export function FilterBar({
         {/* ── Spacer ── */}
         <div className="flex-1" />
 
+        {/* ── Show Hidden Toggle ──
+            Surfaces only when the user has at least one "seen" listing hidden.
+            Reveals those rows in the main list with an Unhide affordance. */}
+        {hiddenCount > 0 && onToggleShowHidden && (
+          <Button
+            type="button"
+            size="sm"
+            variant={showHidden ? 'secondary' : 'ghost'}
+            className="h-8 text-xs gap-1.5"
+            onClick={onToggleShowHidden}
+            aria-pressed={showHidden}
+            aria-label={showHidden ? 'Hide previously-seen listings' : 'Show hidden listings'}
+          >
+            {showHidden ? <Eye className="h-3.5 w-3.5" /> : <EyeOff className="h-3.5 w-3.5" />}
+            {showHidden ? `Showing hidden (${hiddenCount})` : `Hidden (${hiddenCount})`}
+          </Button>
+        )}
+
         {/* ── Action Buttons (right side) ── */}
         <Button
           type="button"
diff --git a/frontend/src/hooks/__tests__/useDecisions.test.tsx b/frontend/src/hooks/__tests__/useDecisions.test.tsx
new file mode 100644
index 0000000..6eeff9b
--- /dev/null
+++ b/frontend/src/hooks/__tests__/useDecisions.test.tsx
@@ -0,0 +1,123 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { renderHook, act, waitFor } from '@testing-library/react';
+import { useDecisions } from '@/hooks/useDecisions';
+import type { AuthUser } from '@/auth/types';
+
+vi.mock('@/services', () => ({
+  fetchDecisions: vi.fn(),
+  setDecision: vi.fn(),
+  clearDecision: vi.fn(),
+}));
+
+import { fetchDecisions, setDecision, clearDecision } from '@/services';
+
+const fetchDecisionsMock = vi.mocked(fetchDecisions);
+const setDecisionMock = vi.mocked(setDecision);
+const clearDecisionMock = vi.mocked(clearDecision);
+
+const user: AuthUser = {
+  sub: 'u1',
+  email: 't@example.com',
+  name: 'Test',
+  accessToken: 'tok',
+  provider: 'oidc',
+};
+
+describe('useDecisions — markSeen + price snapshot', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    fetchDecisionsMock.mockResolvedValue([]);
+    setDecisionMock.mockImplementation(async (_u, listing_id, decision, listing_type, price) => ({
+      id: 1,
+      listing_id,
+      listing_type: listing_type ?? 'RENT',
+      decision,
+      price_at_decision: price ?? null,
+      created_at: '2026-05-16T00:00:00Z',
+      updated_at: '2026-05-16T00:00:00Z',
+    }));
+    clearDecisionMock.mockResolvedValue();
+  });
+
+  it('markSeen persists the current price', async () => {
+    const { result } = renderHook(() => useDecisions(user));
+    await waitFor(() => expect(result.current.isLoaded).toBe(true));
+    await act(async () => {
+      await result.current.markSeen(100, 2500, 'RENT');
+    });
+    expect(setDecisionMock).toHaveBeenCalledWith(user, 100, 'seen', 'RENT', 2500);
+    const entry = result.current.getDecisionEntry(100, 'RENT');
+    expect(entry?.decision).toBe('seen');
+    expect(entry?.price_at_decision).toBe(2500);
+  });
+
+  it('markSeen skips when the existing decision is liked', async () => {
+    fetchDecisionsMock.mockResolvedValueOnce([
+      {
+        id: 1, listing_id: 100, listing_type: 'RENT',
+        decision: 'liked', created_at: '', updated_at: '',
+      },
+    ]);
+    const { result } = renderHook(() => useDecisions(user));
+    await waitFor(() => expect(result.current.isLoaded).toBe(true));
+    await act(async () => {
+      await result.current.markSeen(100, 2500, 'RENT');
+    });
+    expect(setDecisionMock).not.toHaveBeenCalled();
+    expect(result.current.getDecisionEntry(100, 'RENT')?.decision).toBe('liked');
+  });
+
+  it('markSeen skips when the existing decision is disliked', async () => {
+    fetchDecisionsMock.mockResolvedValueOnce([
+      {
+        id: 1, listing_id: 100, listing_type: 'RENT',
+        decision: 'disliked', created_at: '', updated_at: '',
+      },
+    ]);
+    const { result } = renderHook(() => useDecisions(user));
+    await waitFor(() => expect(result.current.isLoaded).toBe(true));
+    await act(async () => {
+      await result.current.markSeen(100, 2500, 'RENT');
+    });
+    expect(setDecisionMock).not.toHaveBeenCalled();
+  });
+
+  it('markSeen re-marks an existing seen with the latest price', async () => {
+    fetchDecisionsMock.mockResolvedValueOnce([
+      {
+        id: 1, listing_id: 100, listing_type: 'RENT',
+        decision: 'seen', price_at_decision: 2500,
+        created_at: '', updated_at: '',
+      },
+    ]);
+    const { result } = renderHook(() => useDecisions(user));
+    await waitFor(() => expect(result.current.isLoaded).toBe(true));
+    // Listing's live price changed; re-marking captures the new snapshot.
+    await act(async () => {
+      await result.current.markSeen(100, 2300, 'RENT');
+    });
+    expect(setDecisionMock).toHaveBeenCalledWith(user, 100, 'seen', 'RENT', 2300);
+    expect(result.current.getDecisionEntry(100, 'RENT')?.price_at_decision).toBe(2300);
+  });
+
+  it('markSeen sends null when the live price is missing', async () => {
+    const { result } = renderHook(() => useDecisions(user));
+    await waitFor(() => expect(result.current.isLoaded).toBe(true));
+    await act(async () => {
+      await result.current.markSeen(100, null, 'RENT');
+    });
+    expect(setDecisionMock).toHaveBeenCalledWith(user, 100, 'seen', 'RENT', null);
+  });
+
+  it('seenCount tracks only seen rows', async () => {
+    fetchDecisionsMock.mockResolvedValueOnce([
+      { id: 1, listing_id: 1, listing_type: 'RENT', decision: 'seen', price_at_decision: 100, created_at: '', updated_at: '' },
+      { id: 2, listing_id: 2, listing_type: 'RENT', decision: 'seen', price_at_decision: 200, created_at: '', updated_at: '' },
+      { id: 3, listing_id: 3, listing_type: 'RENT', decision: 'liked', created_at: '', updated_at: '' },
+    ]);
+    const { result } = renderHook(() => useDecisions(user));
+    await waitFor(() => expect(result.current.isLoaded).toBe(true));
+    expect(result.current.seenCount).toBe(2);
+    expect(result.current.likedCount).toBe(1);
+  });
+});
diff --git a/frontend/src/hooks/useDecisions.ts b/frontend/src/hooks/useDecisions.ts
index aa20a88..03aa4ca 100644
--- a/frontend/src/hooks/useDecisions.ts
+++ b/frontend/src/hooks/useDecisions.ts
@@ -7,8 +7,15 @@ function decisionKey(listingId: number, listingType: string): string {
   return `${listingId}-${listingType}`;
 }
 
+// Stored value per (listing_id, listing_type). price_at_decision is only
+// meaningful for decision='seen' (powers the price-change resurfacing).
+export interface DecisionEntry {
+  decision: DecisionType;
+  price_at_decision?: number | null;
+}
+
 export function useDecisions(user: AuthUser | null) {
-  const [decisions, setDecisions] = useState<Map<string, DecisionType>>(new Map());
+  const [decisions, setDecisions] = useState<Map<string, DecisionEntry>>(new Map());
   const [isLoaded, setIsLoaded] = useState(false);
 
   // Load decisions on mount
@@ -16,9 +23,12 @@ export function useDecisions(user: AuthUser | null) {
     if (!user) return;
     fetchDecisions(user)
       .then((list) => {
-        const map = new Map<string, DecisionType>();
+        const map = new Map<string, DecisionEntry>();
         for (const d of list) {
-          map.set(decisionKey(d.listing_id, d.listing_type), d.decision);
+          map.set(decisionKey(d.listing_id, d.listing_type), {
+            decision: d.decision,
+            price_at_decision: d.price_at_decision ?? null,
+          });
         }
         setDecisions(map);
         setIsLoaded(true);
@@ -27,19 +37,28 @@ export function useDecisions(user: AuthUser | null) {
   }, [user]);
 
   const decide = useCallback(
-    async (listingId: number, decision: DecisionType, listingType: 'RENT' | 'BUY' = 'RENT') => {
+    async (
+      listingId: number,
+      decision: DecisionType,
+      listingType: 'RENT' | 'BUY' = 'RENT',
+      priceAtDecision?: number | null,
+    ) => {
       if (!user) return;
       const key = decisionKey(listingId, listingType);
+      const entry: DecisionEntry = {
+        decision,
+        price_at_decision: decision === 'seen' ? priceAtDecision ?? null : null,
+      };
 
       // Optimistic update
       setDecisions((prev) => {
         const next = new Map(prev);
-        next.set(key, decision);
+        next.set(key, entry);
         return next;
       });
 
       try {
-        await apiSetDecision(user, listingId, decision, listingType);
+        await apiSetDecision(user, listingId, decision, listingType, priceAtDecision);
       } catch {
         // Revert on failure
         setDecisions((prev) => {
@@ -79,22 +98,66 @@ export function useDecisions(user: AuthUser | null) {
     [user, decisions],
   );
 
+  // Liked / disliked decisions are never auto-overwritten by `seen`:
+  // - liked: opening a saved listing shouldn't bury it.
+  // - disliked: explicit user action takes precedence over passive dwell.
+  // `seen` re-marks with the latest price (refreshes the snapshot so a
+  // subsequent price change still resurfaces the listing).
+  const markSeen = useCallback(
+    async (
+      listingId: number,
+      currentPrice: number | null | undefined,
+      listingType: 'RENT' | 'BUY' = 'RENT',
+    ) => {
+      if (!user) return;
+      const key = decisionKey(listingId, listingType);
+      const existing = decisions.get(key);
+      if (existing?.decision === 'liked' || existing?.decision === 'disliked') return;
+      const price = typeof currentPrice === 'number' && Number.isFinite(currentPrice) ? currentPrice : null;
+      await decide(listingId, 'seen', listingType, price);
+    },
+    [user, decisions, decide],
+  );
+
   const getDecision = useCallback(
     (listingId: number, listingType: string = 'RENT'): DecisionType | undefined => {
+      return decisions.get(decisionKey(listingId, listingType))?.decision;
+    },
+    [decisions],
+  );
+
+  const getDecisionEntry = useCallback(
+    (listingId: number, listingType: string = 'RENT'): DecisionEntry | undefined => {
       return decisions.get(decisionKey(listingId, listingType));
     },
     [decisions],
   );
 
   const likedCount = useMemo(
-    () => Array.from(decisions.values()).filter((d) => d === 'liked').length,
+    () => Array.from(decisions.values()).filter((d) => d.decision === 'liked').length,
     [decisions],
   );
 
   const dislikedCount = useMemo(
-    () => Array.from(decisions.values()).filter((d) => d === 'disliked').length,
+    () => Array.from(decisions.values()).filter((d) => d.decision === 'disliked').length,
     [decisions],
   );
 
-  return { decisions, isLoaded, decide, clear, getDecision, likedCount, dislikedCount };
+  const seenCount = useMemo(
+    () => Array.from(decisions.values()).filter((d) => d.decision === 'seen').length,
+    [decisions],
+  );
+
+  return {
+    decisions,
+    isLoaded,
+    decide,
+    clear,
+    markSeen,
+    getDecision,
+    getDecisionEntry,
+    likedCount,
+    dislikedCount,
+    seenCount,
+  };
 }
diff --git a/frontend/src/services/__tests__/decisionService.test.ts b/frontend/src/services/__tests__/decisionService.test.ts
new file mode 100644
index 0000000..e4f7ed5
--- /dev/null
+++ b/frontend/src/services/__tests__/decisionService.test.ts
@@ -0,0 +1,66 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { setDecision } from '@/services/decisionService';
+import type { AuthUser } from '@/auth/types';
+
+vi.mock('@/services/apiClient', () => ({
+  apiRequest: vi.fn(),
+}));
+
+import { apiRequest } from '@/services/apiClient';
+
+const apiRequestMock = vi.mocked(apiRequest);
+
+const user: AuthUser = {
+  sub: 'u1',
+  email: 't@example.com',
+  name: 'Test',
+  accessToken: 'tok',
+  provider: 'oidc',
+};
+
+describe('decisionService.setDecision', () => {
+  beforeEach(() => {
+    apiRequestMock.mockReset();
+    apiRequestMock.mockResolvedValue({} as never);
+  });
+
+  it("sends price_at_decision when decision='seen'", async () => {
+    await setDecision(user, 100, 'seen', 'RENT', 2500);
+    expect(apiRequestMock).toHaveBeenCalledWith(user, '/api/decisions/100', {
+      method: 'PUT',
+      body: { decision: 'seen', listing_type: 'RENT', price_at_decision: 2500 },
+    });
+  });
+
+  it("drops price_at_decision for decision='liked' (server would null it anyway)", async () => {
+    await setDecision(user, 100, 'liked', 'RENT', 9999);
+    expect(apiRequestMock).toHaveBeenCalledWith(user, '/api/decisions/100', {
+      method: 'PUT',
+      body: { decision: 'liked', listing_type: 'RENT' },
+    });
+  });
+
+  it("drops price_at_decision for decision='disliked'", async () => {
+    await setDecision(user, 100, 'disliked', 'BUY', 9999);
+    expect(apiRequestMock).toHaveBeenCalledWith(user, '/api/decisions/100', {
+      method: 'PUT',
+      body: { decision: 'disliked', listing_type: 'BUY' },
+    });
+  });
+
+  it("omits price_at_decision when seen but no price supplied", async () => {
+    await setDecision(user, 100, 'seen', 'RENT');
+    expect(apiRequestMock).toHaveBeenCalledWith(user, '/api/decisions/100', {
+      method: 'PUT',
+      body: { decision: 'seen', listing_type: 'RENT' },
+    });
+  });
+
+  it("omits price_at_decision when seen but price is non-finite", async () => {
+    await setDecision(user, 100, 'seen', 'RENT', NaN);
+    expect(apiRequestMock).toHaveBeenCalledWith(user, '/api/decisions/100', {
+      method: 'PUT',
+      body: { decision: 'seen', listing_type: 'RENT' },
+    });
+  });
+});
diff --git a/frontend/src/services/decisionService.ts b/frontend/src/services/decisionService.ts
index db16dee..94b363d 100644
--- a/frontend/src/services/decisionService.ts
+++ b/frontend/src/services/decisionService.ts
@@ -1,7 +1,7 @@
-// Decision API service for managing listing decisions (like/dislike)
+// Decision API service for managing listing decisions (like/dislike/seen)
 
 import type { AuthUser } from '@/auth/types';
-import type { ListingDecision } from '@/types';
+import type { DecisionType, ListingDecision } from '@/types';
 import { apiRequest } from './apiClient';
 
 export async function fetchDecisions(user: AuthUser): Promise<ListingDecision[]> {
@@ -11,12 +11,19 @@ export async function fetchDecisions(user: AuthUser): Promise<ListingDecision[]>
 export async function setDecision(
   user: AuthUser,
   listingId: number,
-  decision: 'liked' | 'disliked',
+  decision: DecisionType,
   listingType: 'RENT' | 'BUY' = 'RENT',
+  priceAtDecision?: number | null,
 ): Promise<ListingDecision> {
+  const body: Record<string, unknown> = { decision, listing_type: listingType };
+  // Only send the price column for 'seen' — the backend already drops it for
+  // other decision types, but keeping the payload tight saves bytes.
+  if (decision === 'seen' && typeof priceAtDecision === 'number' && Number.isFinite(priceAtDecision)) {
+    body.price_at_decision = priceAtDecision;
+  }
   return apiRequest<ListingDecision>(user, `/api/decisions/${listingId}`, {
     method: 'PUT',
-    body: { decision, listing_type: listingType },
+    body,
   });
 }
 
diff --git a/frontend/src/types/index.ts b/frontend/src/types/index.ts
index 6173ad8..aabb2b2 100644
--- a/frontend/src/types/index.ts
+++ b/frontend/src/types/index.ts
@@ -182,13 +182,19 @@ export interface WSPongMessage {
 export type WSMessage = WSInitMessage | WSTaskUpdateMessage | WSPongMessage;
 
 // Decision types
-export type DecisionType = 'liked' | 'disliked';
+// `seen` is a soft-hide: the listing is removed from the main list by default
+// but can be re-revealed via the "Show hidden" filter toggle. Distinct from
+// `disliked` — seen listings resurface automatically when their price changes.
+export type DecisionType = 'liked' | 'disliked' | 'seen';
 
 export interface ListingDecision {
   id: number;
   listing_id: number;
   listing_type: 'RENT' | 'BUY';
   decision: DecisionType;
+  // Total price at the time the user marked the listing seen. Only populated
+  // for decision='seen'; null otherwise.
+  price_at_decision?: number | null;
   created_at: string;
   updated_at: string;
 }
diff --git a/models/decision.py b/models/decision.py
index 50ebf27..2116562 100644
--- a/models/decision.py
+++ b/models/decision.py
@@ -15,6 +15,10 @@ class ListingDecision(SQLModel, table=True):
     user_id: int = Field(nullable=False, foreign_key="user.id", index=True)
     listing_id: int = Field(nullable=False, index=True)
     listing_type: str = Field(nullable=False)  # "RENT" or "BUY"
-    decision: str = Field(nullable=False)       # "liked" or "disliked"
+    decision: str = Field(nullable=False)       # "liked" | "disliked" | "seen"
+    # Total price at the time the user marked the listing seen. Only set for
+    # decision="seen"; used client-side to resurface listings whose price has
+    # changed since the user dismissed them.
+    price_at_decision: float | None = Field(default=None, nullable=True)
     created_at: datetime = Field(default_factory=datetime.utcnow)
     updated_at: datetime = Field(default_factory=datetime.utcnow)
diff --git a/repositories/decision_repository.py b/repositories/decision_repository.py
index 4421ccf..6dab4a6 100644
--- a/repositories/decision_repository.py
+++ b/repositories/decision_repository.py
@@ -19,6 +19,7 @@ class DecisionRepository:
         listing_id: int,
         listing_type: str,
         decision: str,
+        price_at_decision: float | None = None,
     ) -> ListingDecision:
         """Create or update a decision. Uses dialect-specific upsert."""
         t0 = time.monotonic()
@@ -29,6 +30,7 @@ class DecisionRepository:
                 "listing_id": listing_id,
                 "listing_type": listing_type,
                 "decision": decision,
+                "price_at_decision": price_at_decision,
                 "created_at": now,
                 "updated_at": now,
             }
@@ -38,6 +40,7 @@ class DecisionRepository:
                 stmt = mysql_insert(ListingDecision).values(**values)
                 stmt = stmt.on_duplicate_key_update(
                     decision=stmt.inserted.decision,
+                    price_at_decision=stmt.inserted.price_at_decision,
                     updated_at=stmt.inserted.updated_at,
                 )
             else:
@@ -47,6 +50,7 @@ class DecisionRepository:
                     index_elements=["user_id", "listing_id", "listing_type"],
                     set_={
                         "decision": stmt.excluded.decision,
+                        "price_at_decision": stmt.excluded.price_at_decision,
                         "updated_at": stmt.excluded.updated_at,
                     },
                 )
diff --git a/services/decision_service.py b/services/decision_service.py
index ab6b888..54a220c 100644
--- a/services/decision_service.py
+++ b/services/decision_service.py
@@ -6,7 +6,7 @@ This module provides the core business logic for listing decision operations
 from models.decision import ListingDecision
 from repositories.decision_repository import DecisionRepository
 
-VALID_DECISIONS = {"liked", "disliked"}
+VALID_DECISIONS = {"liked", "disliked", "seen"}
 VALID_LISTING_TYPES = {"RENT", "BUY"}
 
 
@@ -16,8 +16,13 @@ def set_decision(
     listing_id: int,
     listing_type: str,
     decision: str,
+    price_at_decision: float | None = None,
 ) -> ListingDecision:
-    """Set or update a like/dislike decision for a listing."""
+    """Set or update a decision for a listing.
+
+    price_at_decision is only meaningful for decision="seen"; it lets the
+    client resurface a listing whose price has changed since dismissal.
+    """
     if decision not in VALID_DECISIONS:
         raise ValueError(
             f"Invalid decision: {decision}. Must be one of {VALID_DECISIONS}"
@@ -26,7 +31,12 @@ def set_decision(
         raise ValueError(
             f"Invalid listing_type: {listing_type}. Must be one of {VALID_LISTING_TYPES}"
         )
-    return repository.upsert_decision(user_id, listing_id, listing_type, decision)
+    # Only carry the price column when the decision is "seen" — liked/disliked
+    # decisions ignore it. This keeps the column null for those rows.
+    price = price_at_decision if decision == "seen" else None
+    return repository.upsert_decision(
+        user_id, listing_id, listing_type, decision, price
+    )
 
 
 def get_user_decisions(
diff --git a/tests/unit/test_decision_service.py b/tests/unit/test_decision_service.py
index 6abddbb..875a834 100644
--- a/tests/unit/test_decision_service.py
+++ b/tests/unit/test_decision_service.py
@@ -17,8 +17,9 @@ class TestSetDecision:
             listing_type="RENT", decision="liked",
         )
         assert result.decision == "liked"
+        # 5th arg is the price column; liked/disliked decisions drop it.
         repo.upsert_decision.assert_called_once_with(
-            1, 100, "RENT", "liked"
+            1, 100, "RENT", "liked", None
         )
 
     def test_set_disliked(self) -> None:
@@ -48,6 +49,42 @@ class TestSetDecision:
                 listing_type="SELL", decision="liked",
             )
 
+    def test_set_seen_carries_price(self) -> None:
+        """`seen` decisions persist the price-at-mark so the client can
+        resurface listings whose price has changed since dismissal."""
+        repo = MagicMock()
+        repo.upsert_decision.return_value = ListingDecision(
+            id=1, user_id=1, listing_id=100, listing_type="RENT",
+            decision="seen", price_at_decision=2500.0,
+        )
+        result = decision_service.set_decision(
+            repo, user_id=1, listing_id=100,
+            listing_type="RENT", decision="seen",
+            price_at_decision=2500.0,
+        )
+        assert result.decision == "seen"
+        assert result.price_at_decision == 2500.0
+        repo.upsert_decision.assert_called_once_with(
+            1, 100, "RENT", "seen", 2500.0
+        )
+
+    def test_liked_drops_price_even_if_supplied(self) -> None:
+        """price_at_decision is only meaningful for seen — liked/disliked must
+        ignore it so the column stays null on those rows."""
+        repo = MagicMock()
+        repo.upsert_decision.return_value = ListingDecision(
+            id=1, user_id=1, listing_id=100, listing_type="RENT",
+            decision="liked",
+        )
+        decision_service.set_decision(
+            repo, user_id=1, listing_id=100,
+            listing_type="RENT", decision="liked",
+            price_at_decision=999.0,
+        )
+        repo.upsert_decision.assert_called_once_with(
+            1, 100, "RENT", "liked", None
+        )
+
 
 class TestGetDecisions:
     def test_returns_all_decisions(self) -> None: