diff --git a/src/app/[locale]/u/[username]/page.tsx b/src/app/[locale]/u/[username]/page.tsx
index 46877bd..3bfde61 100644
--- a/src/app/[locale]/u/[username]/page.tsx
+++ b/src/app/[locale]/u/[username]/page.tsx
@@ -15,7 +15,15 @@ import {
   getSimilarAccounts,
   getUserMatchups,
 } from "@/lib/db";
-import { getCachedScan } from "@/lib/redis";
+import {
+  beginStaleScoreRefresh,
+  coalesceScan,
+  deleteCachedScan,
+  finishStaleScoreRefresh,
+  getCachedScan,
+} from "@/lib/redis";
+import { buildScanResult } from "@/lib/scan-core";
+import { recordDeterministicScan } from "@/lib/score-persist";
 import { aggregateLanguages, collectTopics } from "@/lib/profile-insights";
 import { PendingProfile } from "./PendingProfile";
 import { LiveRoast } from "@/components/LiveRoast";
@@ -57,8 +65,32 @@ export const dynamic = "force-dynamic";
 
 // Dedupe the DB read between generateMetadata() and the page render.
 const getDetail = cache((username: string) => getAccountDetail(username));
+const getStaleDetail = cache((username: string) =>
+  getAccountDetail(username, { includeStale: true }),
+);
 // Dedupe the cached-scan read (pending-profile fallback) across the same pair.
 const getLiveScan = cache((username: string) => getCachedScan(username));
+async function requestIp(): Promise<string> {
+  const h = await headers();
+  const fwd = h.get("x-forwarded-for");
+  return fwd?.split(",")[0]?.trim() || h.get("x-real-ip") || "0.0.0.0";
+}
+
+const refreshStaleDetail = cache(async (username: string, ip: string) => {
+  const guard = await beginStaleScoreRefresh(username, ip);
+  if (!guard.allowed) return null;
+  try {
+    const scan = await coalesceScan(username, () => buildScanResult(username));
+    await recordDeterministicScan(scan);
+    await deleteCachedScan(scan.metrics.username);
+    return getAccountDetail(scan.metrics.username);
+  } catch (e) {
+    console.error("stale score refresh failed:", e);
+    return null;
+  } finally {
+    await finishStaleScoreRefresh(username);
+  }
+});
 
 export async function generateMetadata({
   params,
@@ -83,6 +115,13 @@ export async function generateMetadata({
         robots: { index: false, follow: true },
       };
     }
+    const stale = await getStaleDetail(decoded);
+    if (stale) {
+      return {
+        title: t("staleTitle", { username: stale.username }),
+        robots: { index: false, follow: true },
+      };
+    }
     return { title: t("notFoundTitle") };
   }
 
@@ -133,7 +172,8 @@ export default async function AccountPage({
   const { locale, username } = await params;
   setRequestLocale(locale);
   const decoded = decodeURIComponent(username);
-  const d = await getDetail(decoded);
+  let d = await getDetail(decoded);
+  let staleFallback = false;
   if (!d) {
     // First-time username being roasted right now: no `scores` row yet. Render
     // the live pending shell when we have a scan to show — either the server-side
@@ -142,8 +182,17 @@ export default async function AccountPage({
     // completion. Otherwise it's a genuine unknown handle → 404.
     const scan = await getLiveScan(decoded);
     const roasting = (await searchParams)?.roasting === "1";
-    if (!scan && !roasting) notFound();
-    return <PendingProfile username={decoded} initialScan={scan ?? null} />;
+    if (!scan && !roasting) {
+      const stale = await getStaleDetail(decoded);
+      if (!stale) notFound();
+      d = await refreshStaleDetail(stale.username, await requestIp());
+      if (!d) {
+        d = stale;
+        staleFallback = true;
+      }
+    } else {
+      return <PendingProfile username={decoded} initialScan={scan ?? null} />;
+    }
   }
 
   const t = await getTranslations("detail");
@@ -162,17 +211,19 @@ export default async function AccountPage({
   // Row exists but this language's roast is missing (e.g. an English visitor on a
   // zh-only roast). If the scan is still cached, stream a live roast in the
   // report slot instead of the "run a roast" empty state.
-  const liveScan = !roast && !roastLine ? await getLiveScan(d.username) : null;
-  const [similar, comments, snap, rank, session, battles, facetRank] =
-    await Promise.all([
-      getSimilarAccounts(d.username, d.final_score, d.sub_scores),
-      getProfileComments(d.username),
-      getProfileSnapshot(d.username),
-      getRank(d.final_score),
-      authConfigured() ? auth() : Promise.resolve(null),
-      getUserMatchups(d.username),
-      getFacetRank(d.username, d.final_score),
-    ]);
+  const liveScan =
+    !staleFallback && !roast && !roastLine ? await getLiveScan(d.username) : null;
+  const [similar, comments, snap, rank, session, battles, facetRank] = await Promise.all([
+    staleFallback
+      ? Promise.resolve([])
+      : getSimilarAccounts(d.username, d.final_score, d.sub_scores),
+    getProfileComments(d.username),
+    getProfileSnapshot(d.username, { includeStale: staleFallback }),
+    staleFallback ? Promise.resolve(null) : getRank(d.final_score),
+    authConfigured() ? auth() : Promise.resolve(null),
+    getUserMatchups(d.username),
+    staleFallback ? Promise.resolve(null) : getFacetRank(d.username, d.final_score),
+  ]);
   // Inline re-detect is self-service: only the signed-in owner sees it on their
   // own profile. GitHub handles are case-insensitive, so compare normalized.
   const isOwner =
@@ -257,6 +308,13 @@ export default async function AccountPage({
           <BadgeReferralBanner owner={d.username} signal={badgeSignal!} />
         )}
 
+        {staleFallback && (
+          <section className="mt-4 rounded-2xl border border-orange-300/30 bg-orange-500/[0.08] p-4 text-sm leading-6 text-zinc-200 shadow-[0_18px_60px_rgba(0,0,0,0.18)]">
+            <div className="font-bold text-orange-300">{t("staleBadge")}</div>
+            <p className="mt-1 text-zinc-300">{t("staleBody")}</p>
+          </section>
+        )}
+
       <div className="mt-4 flex flex-col gap-6 lg:flex-row lg:items-start">
         {/* Left: sticky identity sidebar — score stays visible while reading */}
         <aside className="flex flex-col gap-4 lg:sticky lg:top-8 lg:w-80 lg:shrink-0">
diff --git a/src/app/api/score/[username]/route.ts b/src/app/api/score/[username]/route.ts
index f95862d..e9ae4c1 100644
--- a/src/app/api/score/[username]/route.ts
+++ b/src/app/api/score/[username]/route.ts
@@ -6,6 +6,7 @@ import { TIER_KEY } from "@/lib/tier";
 import { SITE_URL } from "@/lib/site";
 import { checkRateLimit, coalesceScan, getCachedScan } from "@/lib/redis";
 import { buildScanResult, scanErrorResponse } from "@/lib/scan-core";
+import { recordDeterministicScan } from "@/lib/score-persist";
 import type { ScanResult, Tier } from "@/lib/types";
 
 export const runtime = "nodejs";
@@ -95,6 +96,7 @@ export async function GET(
   }
 
   // 2) Not indexed → score it live, deterministically (NO LLM).
+  const staleDetail = await getAccountDetail(handle, { includeStale: true });
   const cached = await getCachedScan(handle);
   if (!cached) {
     const { success } = await checkRateLimit(clientIp(req));
@@ -115,6 +117,9 @@ export async function GET(
   if (!cached) {
     await recordAccountLookup(result.metrics.username, clientIp(req));
   }
+  if (staleDetail) {
+    await recordDeterministicScan(result);
+  }
 
   const s = result.scoring;
   const m = result.metrics;
diff --git a/src/lib/__tests__/db.test.ts b/src/lib/__tests__/db.test.ts
index fdc1990..3951250 100644
--- a/src/lib/__tests__/db.test.ts
+++ b/src/lib/__tests__/db.test.ts
@@ -3,10 +3,12 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { createClient } from "@libsql/client";
 import { afterAll, beforeAll, describe, expect, it } from "vitest";
-import { ROAST_CACHE_VERSION } from "../cache-version";
+import { ROAST_CACHE_VERSION, SCORE_CACHE_VERSION } from "../cache-version";
 import type { ScoreEntry } from "../db";
+import type { ScanResult } from "../types";
 
 let db: typeof import("../db");
+let persist: typeof import("../score-persist");
 let tmpDir: string;
 
 const entry: ScoreEntry = {
@@ -35,6 +37,7 @@ beforeAll(async () => {
   process.env.TURSO_DATABASE_URL = `file:${join(tmpDir, "test.db")}`;
   delete process.env.TURSO_AUTH_TOKEN;
   db = await import("../db");
+  persist = await import("../score-persist");
 });
 
 afterAll(() => {
@@ -89,6 +92,153 @@ describe("getArchivedRoast", () => {
   });
 });
 
+describe("current score reads", () => {
+  it("does not expose stale score rows as current account details", async () => {
+    await db.recordScore({ ...entry, username: "stale-score" });
+
+    const client = createClient({ url: process.env.TURSO_DATABASE_URL! });
+    await client.execute({
+      sql: `UPDATE scores SET score_version = ? WHERE username = ?`,
+      args: [`${SCORE_CACHE_VERSION}-old`, "stale-score"],
+    });
+
+    await expect(db.getAccountDetail("stale-score")).resolves.toBeNull();
+    await expect(
+      db.getAccountDetail("stale-score", { includeStale: true }),
+    ).resolves.toMatchObject({
+      username: "stale-score",
+      final_score: entry.final_score,
+    });
+  });
+
+  it("does not expose stale profile snapshots as current evidence", async () => {
+    const client = createClient({ url: process.env.TURSO_DATABASE_URL! });
+    await client.execute({
+      sql: `INSERT INTO profile_snapshots
+              (id, username, scanned_at, top_repos, impact_repos, verified_prs,
+               metrics, pinned_repos, organizations, scan_version)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      args: [
+        "stale-snapshot-id",
+        "stale-snapshot",
+        1,
+        "[]",
+        "[]",
+        "[]",
+        "{}",
+        "[]",
+        "[]",
+        `${SCORE_CACHE_VERSION}-old`,
+      ],
+    });
+
+    await expect(db.getProfileSnapshot("stale-snapshot")).resolves.toBeNull();
+    await expect(
+      db.getProfileSnapshot("stale-snapshot", { includeStale: true }),
+    ).resolves.toMatchObject({ scanned_at: 1 });
+  });
+
+  it("excludes stale score rows from public score surfaces", async () => {
+    await db.recordScore({ ...entry, username: "current-public", final_score: 91 });
+    await db.recordScore({ ...entry, username: "stale-public", final_score: 100 });
+
+    const client = createClient({ url: process.env.TURSO_DATABASE_URL! });
+    await client.execute({
+      sql: `UPDATE scores SET score_version = ? WHERE username = ?`,
+      args: [`${SCORE_CACHE_VERSION}-old`, "stale-public"],
+    });
+
+    const board = await db.getLeaderboard(20, 90);
+    expect(board.map((e) => e.username)).toContain("current-public");
+    expect(board.map((e) => e.username)).not.toContain("stale-public");
+
+    await expect(db.getScoreBrief("stale-public")).resolves.toBeNull();
+    await expect(db.searchScoredUsers("stale-public")).resolves.toEqual([]);
+  });
+
+  it("can refresh a stale score row with deterministic scan output", async () => {
+    await db.recordScore({ ...entry, username: "auto-refresh", final_score: 40 });
+
+    const client = createClient({ url: process.env.TURSO_DATABASE_URL! });
+    await client.execute({
+      sql: `UPDATE scores SET score_version = ? WHERE username = ?`,
+      args: [`${SCORE_CACHE_VERSION}-old`, "auto-refresh"],
+    });
+
+    const scan: ScanResult = {
+      metrics: {
+        username: "auto-refresh",
+        profile_url: "https://github.com/auto-refresh",
+        avatar_url: null,
+        name: "Auto Refresh",
+        bio: null,
+        company: null,
+        account_age_years: 3,
+        created_at: "2023-01-01T00:00:00Z",
+        followers: 2,
+        following: 0,
+        public_repos: 1,
+        fetched_repo_count: 1,
+        original_repo_count: 1,
+        nonempty_original_repo_count: 1,
+        fork_repo_count: 0,
+        empty_original_repo_count: 0,
+        total_stars: 10,
+        max_stars: 10,
+        merged_pr_count: 2,
+        total_pr_count: 2,
+        issues_created: 0,
+        last_year_contributions: 10,
+        activity_type_count: 2,
+        contribution_years_active: 2,
+        days_since_last_activity: 1,
+        recent_merged_pr_sample: 2,
+        recent_trivial_pr_count: 0,
+        external_trivial_pr_count: 0,
+        max_impact_repo_stars: 0,
+        impact_pr_count: 0,
+        impact_depth_raw: 0,
+        star_inflation_suspect: false,
+        closed_unmerged_pr_count: 0,
+        pr_rejection_rate: 0,
+        recent_pr_sample: 2,
+        top_repo_pr_target: null,
+        top_repo_pr_share: 0,
+        templated_pr_ratio: 0,
+        pr_flood_suspect: false,
+      },
+      top_repos: [],
+      recent_prs: [],
+      flood_pr_titles: [],
+      impact_repos: [],
+      verified_impact_prs: [],
+      pinned_repos: [],
+      organizations: [],
+      scoring: {
+        sub_scores: entry.sub_scores,
+        base_score: 73.5,
+        red_flags: [],
+        total_penalty: 0,
+        final_score: 73.5,
+        tier: "人上人",
+        tier_label: "人上人",
+      },
+    };
+
+    await persist.recordDeterministicScan(scan, entry.scanned_at + 1);
+
+    await expect(db.getAccountDetail("auto-refresh")).resolves.toMatchObject({
+      username: "auto-refresh",
+      final_score: 73.5,
+      roast_line: { zh: "", en: "" },
+    });
+    await expect(db.getProfileSnapshot("auto-refresh")).resolves.toMatchObject({
+      top_repos: [],
+      metrics: expect.objectContaining({ total_stars: 10, merged_pr_count: 2 }),
+    });
+  });
+});
+
 describe("score snapshots", () => {
   it("stores one generated-at stub when a completed roast is persisted", async () => {
     const username = "roast-snapshot";
diff --git a/src/lib/__tests__/redis.test.ts b/src/lib/__tests__/redis.test.ts
new file mode 100644
index 0000000..55add65
--- /dev/null
+++ b/src/lib/__tests__/redis.test.ts
@@ -0,0 +1,21 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+describe("stale score refresh guard", () => {
+  afterEach(() => {
+    vi.unstubAllEnvs();
+  });
+
+  it("fails closed when Redis is not configured", async () => {
+    vi.stubEnv("NODE_ENV", "production");
+    vi.stubEnv("UPSTASH_REDIS_REST_URL", undefined);
+    vi.stubEnv("UPSTASH_REDIS_REST_TOKEN", undefined);
+    vi.resetModules();
+
+    const { beginStaleScoreRefresh } = await import("../redis");
+
+    await expect(beginStaleScoreRefresh("stale-user", "203.0.113.9")).resolves.toEqual({
+      allowed: false,
+      reason: "redis_unavailable",
+    });
+  });
+});
diff --git a/src/lib/db.ts b/src/lib/db.ts
index 616f303..2035912 100644
--- a/src/lib/db.ts
+++ b/src/lib/db.ts
@@ -687,6 +687,7 @@ function parseJsonArray<T>(raw: unknown): T[] {
  * (low-score/old accounts never backfilled). Fire-and-forget tolerant. */
 export async function getProfileSnapshot(
   username: string,
+  opts: { includeStale?: boolean } = {},
 ): Promise<ProfileSnapshotView | null> {
   const db = getClient();
   if (!db) return null;
@@ -696,9 +697,12 @@ export async function getProfileSnapshot(
       sql: `SELECT top_repos, impact_repos, pinned_repos, organizations, metrics, scanned_at
             FROM profile_snapshots
             WHERE username = ?
+              ${opts.includeStale ? "" : "AND scan_version = ?"}
             ORDER BY scanned_at DESC
             LIMIT 1`,
-      args: [username.toLowerCase()],
+      args: opts.includeStale
+        ? [username.toLowerCase()]
+        : [username.toLowerCase(), SCORE_CACHE_VERSION],
     });
     const r = res.rows[0];
     if (!r) return null;
@@ -827,9 +831,9 @@ export async function getPercentile(
     await ensureSchema(db);
     const res = await db.execute({
       sql: `SELECT
-              (SELECT COUNT(*) FROM scores WHERE final_score < ?) AS below,
-              (SELECT COUNT(*) FROM scores) AS total`,
-      args: [score],
+              (SELECT COUNT(*) FROM scores WHERE hidden = 0 AND score_version = ? AND final_score < ?) AS below,
+              (SELECT COUNT(*) FROM scores WHERE hidden = 0 AND score_version = ?) AS total`,
+      args: [SCORE_CACHE_VERSION, score, SCORE_CACHE_VERSION],
     });
     const row = res.rows[0];
     if (!row) return null;
@@ -861,8 +865,8 @@ export async function getRank(
               SUM(CASE WHEN final_score > ? THEN 1 ELSE 0 END) AS above,
               SUM(CASE WHEN final_score < ? THEN 1 ELSE 0 END) AS below,
               COUNT(*) AS total
-            FROM scores WHERE hidden = 0`,
-      args: [score, score],
+            FROM scores WHERE hidden = 0 AND score_version = ?`,
+      args: [score, score, SCORE_CACHE_VERSION],
     });
     const row = res.rows[0];
     if (!row) return null;
@@ -977,7 +981,10 @@ export async function getScoreCount(): Promise<number | null> {
   if (!db) return null;
   try {
     await ensureSchema(db);
-    const res = await db.execute("SELECT COUNT(*) AS n FROM scores");
+    const res = await db.execute({
+      sql: "SELECT COUNT(*) AS n FROM scores WHERE score_version = ?",
+      args: [SCORE_CACHE_VERSION],
+    });
     return Number(res.rows[0]?.n ?? 0);
   } catch (e) {
     console.error("getScoreCount failed:", e);
@@ -1047,9 +1054,9 @@ export async function getTrendingLeaderboard(
               WHERE last_counted_at >= ?
               GROUP BY username
             ) AS recent ON recent.username = s.username
-            WHERE s.hidden = 0 AND s.final_score >= ?
+            WHERE s.hidden = 0 AND s.score_version = ? AND s.final_score >= ?
             ${activeOnly ? "AND recent.recent_lookup_count > 0" : ""}`,
-      args: [recentCutoff, minScore],
+      args: [recentCutoff, SCORE_CACHE_VERSION, minScore],
     });
     return rankTrending(
       res.rows.map((r) => ({
@@ -1085,9 +1092,9 @@ export async function getAllPublicUsernames(minScore = 60): Promise<PublicProfil
     const res = await db.execute({
       sql: `SELECT username, scanned_at
             FROM scores
-            WHERE hidden = 0 AND final_score >= ?
+            WHERE hidden = 0 AND score_version = ? AND final_score >= ?
             ORDER BY final_score DESC`,
-      args: [minScore],
+      args: [SCORE_CACHE_VERSION, minScore],
     });
     return res.rows.map((r) => ({
       username: String(r.username),
@@ -1124,11 +1131,11 @@ export async function getLeaderboard(
               WHERE last_counted_at >= ?
               GROUP BY username
             ) AS recent ON recent.username = s.username
-            WHERE s.hidden = 0 AND s.final_score >= ?
+            WHERE s.hidden = 0 AND s.score_version = ? AND s.final_score >= ?
             ${activeOnly ? "AND recent.recent_lookup_count > 0" : ""}
             ORDER BY s.final_score DESC, s.scanned_at DESC
             LIMIT ?`,
-      args: [recentCutoff, minScore, limit],
+      args: [recentCutoff, SCORE_CACHE_VERSION, minScore, limit],
     });
     const now = Date.now();
     return res.rows.map((r) => toLeaderboardEntry(r as unknown as LeaderboardRow, now));
@@ -1166,11 +1173,11 @@ export async function getHeatLeaderboard(
               WHERE last_counted_at >= ?
               GROUP BY username
             ) AS recent ON recent.username = s.username
-            WHERE s.hidden = 0 AND s.final_score >= ?
+            WHERE s.hidden = 0 AND s.score_version = ? AND s.final_score >= ?
             ${activeOnly ? "AND recent.recent_lookup_count > 0" : ""}
             ORDER BY ${heatOrder}, s.final_score DESC, s.scanned_at DESC
             LIMIT ?`,
-      args: [recentCutoff, minScore, limit],
+      args: [recentCutoff, SCORE_CACHE_VERSION, minScore, limit],
     });
     const now = Date.now();
     return res.rows.map((r) => toLeaderboardEntry(r as unknown as LeaderboardRow, now));
@@ -1206,12 +1213,13 @@ export async function getProgressLeaderboard(
               GROUP BY username
             ) AS recent ON recent.username = s.username
             WHERE s.hidden = 0
+              AND s.score_version = ?
               AND s.prev_score IS NOT NULL
               AND s.final_score > s.prev_score
               ${activeOnly ? "AND recent.recent_lookup_count > 0" : ""}
             ORDER BY (s.final_score - s.prev_score) DESC, s.scanned_at DESC
             LIMIT ?`,
-      args: [recentCutoff, limit],
+      args: [recentCutoff, SCORE_CACHE_VERSION, limit],
     });
     const now = Date.now();
     return res.rows.map((r) => {
@@ -1259,11 +1267,12 @@ export async function getFacetCategories(
             JOIN scores AS s ON s.username = f.username
             WHERE f.facet_type = ?
               AND s.hidden = 0
+              AND s.score_version = ?
               AND s.final_score >= ?
             GROUP BY f.facet_value
             ORDER BY count DESC, f.facet_value ASC
             LIMIT ?`,
-      args: [facetType, FACET_MIN_SCORE, Math.max(1, Math.min(500, limit))],
+      args: [facetType, SCORE_CACHE_VERSION, FACET_MIN_SCORE, Math.max(1, Math.min(500, limit))],
     });
     return res.rows.map((r) => ({ value: String(r.value), count: Number(r.count) }));
   } catch (e) {
@@ -1302,10 +1311,11 @@ export async function getDevelopersByFacet(
             WHERE f.facet_type = ?
               AND f.facet_value = ?
               AND s.hidden = 0
+              AND s.score_version = ?
               AND s.final_score >= ?
             ORDER BY s.final_score DESC, s.scanned_at DESC
             LIMIT ?`,
-      args: [facetType, facetValue, FACET_MIN_SCORE, capped],
+      args: [facetType, facetValue, SCORE_CACHE_VERSION, FACET_MIN_SCORE, capped],
     });
     const now = Date.now();
     return res.rows.map((r) => toLeaderboardEntry(r as unknown as LeaderboardRow, now));
@@ -1358,9 +1368,9 @@ export async function getScoreBrief(username: string): Promise<ScoreBrief | null
     const res = await db.execute({
       sql: `SELECT username, display_name, final_score, tier
             FROM scores
-            WHERE username = ? AND hidden = 0
+            WHERE username = ? AND hidden = 0 AND score_version = ?
             LIMIT 1`,
-      args: [username.toLowerCase()],
+      args: [username.toLowerCase(), SCORE_CACHE_VERSION],
     });
     const r = res.rows[0];
     if (!r) return null;
@@ -1406,10 +1416,10 @@ export async function searchScoredUsers(
     const res = await db.execute({
       sql: `SELECT username, display_name, avatar_url, final_score, tier
             FROM scores
-            WHERE hidden = 0 AND username LIKE ? ESCAPE '\\'
+            WHERE hidden = 0 AND score_version = ? AND username LIKE ? ESCAPE '\\'
             ORDER BY final_score DESC
             LIMIT ?`,
-      args: [like, limit],
+      args: [SCORE_CACHE_VERSION, like, limit],
     });
     return res.rows.map((r) => ({
       username: String(r.username),
@@ -1630,8 +1640,11 @@ export async function getIndexableMatchups(): Promise<
   }
 }
 
-/** Full persisted record for one account's detail page (null if absent/hidden). */
-export async function getAccountDetail(username: string): Promise<AccountDetail | null> {
+/** Full persisted record for one account's detail page (null if absent/hidden/stale). */
+export async function getAccountDetail(
+  username: string,
+  opts: { includeStale?: boolean } = {},
+): Promise<AccountDetail | null> {
   const db = getClient();
   if (!db) return null;
   try {
@@ -1641,8 +1654,11 @@ export async function getAccountDetail(username: string): Promise<AccountDetail
                    tags, roast_line, sub_scores, roast, roast_en, scanned_at
             FROM scores
             WHERE username = ? AND hidden = 0
+              ${opts.includeStale ? "" : "AND score_version = ?"}
             LIMIT 1`,
-      args: [username.toLowerCase()],
+      args: opts.includeStale
+        ? [username.toLowerCase()]
+        : [username.toLowerCase(), SCORE_CACHE_VERSION],
     });
     const r = res.rows[0];
     if (!r) return null;
@@ -1739,11 +1755,13 @@ export async function getSimilarAccounts(
             FROM scores AS s
             LEFT JOIN account_stats AS stats ON stats.username = s.username
             WHERE s.hidden = 0
+              AND s.score_version = ?
               AND s.username != ?
               AND s.final_score BETWEEN ? AND ?
             ORDER BY s.final_score DESC
             LIMIT ?`,
       args: [
+        SCORE_CACHE_VERSION,
         username.toLowerCase(),
         finalScore - SIMILAR_SCORE_BAND,
         finalScore + SIMILAR_SCORE_BAND,
diff --git a/src/lib/redis.ts b/src/lib/redis.ts
index 038efc3..3723a3a 100644
--- a/src/lib/redis.ts
+++ b/src/lib/redis.ts
@@ -28,6 +28,8 @@ let roastMinuteLimiter: Ratelimit | null = null;
 let roastDayLimiter: Ratelimit | null = null;
 let verdictMinuteLimiter: Ratelimit | null = null;
 let verdictDayLimiter: Ratelimit | null = null;
+let staleRefreshIpLimiter: Ratelimit | null = null;
+let staleRefreshGlobalLimiter: Ratelimit | null = null;
 
 function getRedis(): Redis | null {
   if (redis) return redis;
@@ -39,9 +41,15 @@ function getRedis(): Redis | null {
 }
 
 const SCAN_TTL_SECONDS = 60 * 60 * 24; // 24h
+const STALE_SCORE_REFRESH_COOLDOWN_SECONDS = 60 * 60 * 3; // 3h
+const STALE_SCORE_REFRESH_LEASE_SECONDS = 60 * 5; // 5m
 export const scanKey = (username: string) =>
   `scan:${SCORE_CACHE_VERSION}:${username.toLowerCase()}`;
 const lockKey = (username: string) => `lock:scan:${username.toLowerCase()}`;
+const staleScoreRefreshCooldownKey = (username: string) =>
+  `cooldown:stale-score-refresh:${SCORE_CACHE_VERSION}:${username.toLowerCase()}`;
+const staleScoreRefreshLeaseKey = (username: string) =>
+  `lock:stale-score-refresh:${SCORE_CACHE_VERSION}:${username.toLowerCase()}`;
 
 const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));
 
@@ -67,6 +75,100 @@ export async function setCachedScan(username: string, scan: ScanResult): Promise
   }
 }
 
+export async function deleteCachedScan(username: string): Promise<void> {
+  const r = getRedis();
+  if (!r) return;
+  try {
+    await r.del(scanKey(username));
+  } catch {
+    // best-effort cache cleanup; ignore failures
+  }
+}
+
+type StaleScoreRefreshGuardReason =
+  | "allowed"
+  | "cache_bypass"
+  | "redis_unavailable"
+  | "cooldown"
+  | "rate_limited"
+  | "in_flight"
+  | "redis_error";
+
+export interface StaleScoreRefreshGuard {
+  allowed: boolean;
+  reason: StaleScoreRefreshGuardReason;
+}
+
+/**
+ * Cost guard for passive stale-profile refreshes.
+ *
+ * Unlike a user-initiated scan, this path is triggered just by visiting an old
+ * profile URL. Therefore it is fail-closed: without Redis (cooldown, limiter,
+ * and lease) we show the stale fallback instead of spending GitHub/DB work.
+ */
+export async function beginStaleScoreRefresh(
+  username: string,
+  ip: string,
+): Promise<StaleScoreRefreshGuard> {
+  if (bypassGeneratedCaches()) return { allowed: false, reason: "cache_bypass" };
+  const r = getRedis();
+  if (!r) return { allowed: false, reason: "redis_unavailable" };
+
+  const cooldownKey = staleScoreRefreshCooldownKey(username);
+  const leaseKey = staleScoreRefreshLeaseKey(username);
+  try {
+    if (await r.get(cooldownKey)) return { allowed: false, reason: "cooldown" };
+
+    if (!staleRefreshIpLimiter) {
+      staleRefreshIpLimiter = new Ratelimit({
+        redis: r,
+        limiter: Ratelimit.slidingWindow(5, "10 m"),
+        prefix: "rl:stale-score-refresh:ip",
+        analytics: false,
+      });
+    }
+    if (!staleRefreshGlobalLimiter) {
+      staleRefreshGlobalLimiter = new Ratelimit({
+        redis: r,
+        limiter: Ratelimit.slidingWindow(30, "60 s"),
+        prefix: "rl:stale-score-refresh:global",
+        analytics: false,
+      });
+    }
+
+    const [perIp, global] = await Promise.all([
+      staleRefreshIpLimiter.limit(ip || "0.0.0.0"),
+      staleRefreshGlobalLimiter.limit("global"),
+    ]);
+    if (!perIp.success || !global.success) {
+      return { allowed: false, reason: "rate_limited" };
+    }
+
+    const acquired = (await r.set(leaseKey, "1", {
+      nx: true,
+      ex: STALE_SCORE_REFRESH_LEASE_SECONDS,
+    })) === "OK";
+    if (!acquired) return { allowed: false, reason: "in_flight" };
+
+    // Set before the expensive scan. If the scan or DB write fails, do not retry
+    // on every page visit; the stale fallback remains visible until cooldown ends.
+    await r.set(cooldownKey, "1", { ex: STALE_SCORE_REFRESH_COOLDOWN_SECONDS });
+    return { allowed: true, reason: "allowed" };
+  } catch {
+    return { allowed: false, reason: "redis_error" };
+  }
+}
+
+export async function finishStaleScoreRefresh(username: string): Promise<void> {
+  const r = getRedis();
+  if (!r) return;
+  try {
+    await r.del(staleScoreRefreshLeaseKey(username));
+  } catch {
+    // best-effort lease cleanup; the lease has a short TTL.
+  }
+}
+
 /**
  * Single-flight a cold scan: when many requests hit the same username at once
  * (cache cold), only the first one calls GitHub; the rest wait for its result
diff --git a/src/lib/score-persist.ts b/src/lib/score-persist.ts
new file mode 100644
index 0000000..7094a63
--- /dev/null
+++ b/src/lib/score-persist.ts
@@ -0,0 +1,33 @@
+import { recordProfileSnapshot, recordScore } from "@/lib/db";
+import { spamBotScore } from "@/lib/score";
+import type { ScanResult } from "@/lib/types";
+
+/**
+ * Persist the deterministic score path only: GitHub scan + local scoring.
+ *
+ * This deliberately does not write roast text or tags. It is used when an old
+ * score-version row is visited and we need to refresh factual scoring without
+ * spending LLM tokens or changing the user's report copy behind the scenes.
+ */
+export async function recordDeterministicScan(
+  scan: ScanResult,
+  scannedAt = Date.now(),
+): Promise<void> {
+  const { metrics, scoring } = scan;
+  await Promise.all([
+    recordScore({
+      username: metrics.username,
+      display_name: metrics.name,
+      avatar_url: metrics.avatar_url,
+      profile_url: metrics.profile_url,
+      final_score: scoring.final_score,
+      tier: scoring.tier,
+      tags: { zh: [], en: [] },
+      roast_line: { zh: "", en: "" },
+      bot_score: spamBotScore(metrics),
+      sub_scores: scoring.sub_scores,
+      scanned_at: scannedAt,
+    }),
+    recordProfileSnapshot(scan),
+  ]);
+}
diff --git a/src/messages/en.json b/src/messages/en.json
index 882e150..fed430c 100644
--- a/src/messages/en.json
+++ b/src/messages/en.json
@@ -154,6 +154,9 @@
     "liveRateLimited": "Too many roasts right now — try again in a minute.",
     "liveExpired": "The scan expired before the roast finished.",
     "liveGoHome": "Roast again from the home page →",
+    "staleBadge": "Historical score: scoring version expired",
+    "staleBody": "The score and report below were generated by an older scoring version and are shown only as a temporary fallback. The app automatically tries to refresh the current-version score on visit; if production infrastructure or GitHub is temporarily unavailable, the same user is retried after the cooldown.",
+    "staleCta": "Re-run from the home page →",
     "modalTitle": "🔥 Your roast is in",
     "modalRoastHeading": "Full roast",
     "modalFirstJudged": "🥇 You're the first to be judged — a true pioneer",
@@ -192,7 +195,8 @@
     "descWithTags": "{tags} — see {username}'s full score report on ghfind.com.",
     "descPlain": "{username}'s GitHub value & trust report — ghfind.com.",
     "notFoundTitle": "Account not found · ghfind",
-    "pendingTitle": "Roasting @{username}… · ghfind"
+    "pendingTitle": "Roasting @{username}… · ghfind",
+    "staleTitle": "@{username}'s score is refreshing · ghfind"
   },
   "roaster": {
     "inputPlaceholder": "Enter a GitHub username or profile URL",
diff --git a/src/messages/zh.json b/src/messages/zh.json
index fd9f902..00864cd 100644
--- a/src/messages/zh.json
+++ b/src/messages/zh.json
@@ -154,6 +154,9 @@
     "liveRateLimited": "当前锐评太频繁，请一分钟后再试。",
     "liveExpired": "扫描数据在锐评完成前过期了。",
     "liveGoHome": "回首页重新锐评 →",
+    "staleBadge": "历史评分：规则版本已过期",
+    "staleBody": "下面展示的是旧规则生成的历史分数和报告，仅用于临时兜底。系统会在访问时自动尝试刷新当前版本评分；若生产环境或 GitHub 暂时不可用，同一用户会在冷却后自动重试。",
+    "staleCta": "回首页重新检测 →",
     "modalTitle": "🔥 你的锐评出炉了",
     "modalRoastHeading": "完整锐评",
     "modalFirstJudged": "🥇 你是第一个被审判的，前无古人",
@@ -192,7 +195,8 @@
     "descWithTags": "{tags} —— 在 ghfind.com 查看 {username} 的完整评分报告。",
     "descPlain": "{username} 的 GitHub 价值评分报告 —— ghfind.com。",
     "notFoundTitle": "查无此号 · ghfind",
-    "pendingTitle": "正在锐评 @{username}… · ghfind"
+    "pendingTitle": "正在锐评 @{username}… · ghfind",
+    "staleTitle": "@{username} 的评分正在刷新 · ghfind"
   },
   "roaster": {
     "inputPlaceholder": "输入 GitHub 用户名或主页链接",