diff --git a/src/app/api/metrics/consistency-score/route.ts b/src/app/api/metrics/consistency-score/route.ts
new file mode 100644
index 00000000..150bba06
--- /dev/null
+++ b/src/app/api/metrics/consistency-score/route.ts
@@ -0,0 +1,233 @@
+import { getServerSession } from "next-auth";
+import { NextRequest } from "next/server";
+import { authOptions } from "@/lib/auth";
+import { getAccountToken, getAllAccounts } from "@/lib/github-accounts";
+import { GITHUB_API } from "@/lib/github";
+import {
+  isMetricsCacheBypassed,
+  METRICS_CACHE_TTL_SECONDS,
+  metricsCacheKey,
+  withMetricsCache,
+} from "@/lib/metrics-cache";
+import { supabaseAdmin } from "@/lib/supabase";
+import { resolveAppUser } from "@/lib/resolve-user";
+import { calculateConsistencyScore } from "@/lib/consistency-score";
+
+export const dynamic = "force-dynamic";
+
+const LOOKBACK_DAYS = 365;
+
+async function fetchActiveDates(
+  githubLogin: string,
+  token: string,
+  cacheContext: { bypass: boolean; userId: string },
+  timeZone = "UTC",
+): Promise<Set<string>> {
+  const key = metricsCacheKey(cacheContext.userId, "streak", { githubLogin });
+
+  const dates = await withMetricsCache(
+    {
+      bypass: cacheContext.bypass,
+      key,
+      ttlSeconds: METRICS_CACHE_TTL_SECONDS.streak,
+    },
+    async () => {
+      const since = new Date();
+      since.setDate(since.getDate() - LOOKBACK_DAYS);
+      const sinceStr = since.toISOString().slice(0, 10);
+
+      const activeDates = new Set<string>();
+      let page = 1;
+
+      while (true) {
+        const searchRes = await fetch(
+          `${GITHUB_API}/search/commits?q=author:${githubLogin}+author-date:>=${sinceStr}&per_page=100&page=${page}&sort=author-date&order=desc`,
+          {
+            headers: {
+              Authorization: `Bearer ${token}`,
+              Accept: "application/vnd.github+json",
+            },
+            cache: "no-store",
+          },
+        );
+
+        if (!searchRes.ok) {
+          throw new Error("GitHub API error");
+        }
+
+        const data = (await searchRes.json()) as {
+          items: Array<{ commit: { author: { date: string } } }>;
+        };
+
+        for (const item of data.items) {
+          const commitDate = new Date(item.commit.author.date);
+          const parts = new Intl.DateTimeFormat("en", {
+            timeZone,
+            year: "numeric",
+            month: "2-digit",
+            day: "2-digit",
+          }).formatToParts(commitDate);
+          const year = parts.find((p) => p.type === "year")?.value;
+          const month = parts.find((p) => p.type === "month")?.value;
+          const day = parts.find((p) => p.type === "day")?.value;
+          if (year && month && day) {
+            activeDates.add(`${year}-${month}-${day}`);
+          }
+        }
+
+        if (data.items.length < 100 || page >= 10) break;
+        page += 1;
+      }
+
+      return Array.from(activeDates);
+    },
+  );
+
+  return new Set(dates);
+}
+
+async function getConsistencyScoreForDates(
+  activeDates: Set<string>,
+  timeZone: string,
+  cacheContext: { bypass: boolean; userId: string; accountKey: string },
+) {
+  const key = `metrics:${cacheContext.userId}:consistency-score:${cacheContext.accountKey}`;
+
+  return withMetricsCache(
+    {
+      bypass: cacheContext.bypass,
+      key,
+      ttlSeconds: METRICS_CACHE_TTL_SECONDS.streak,
+    },
+    async () => calculateConsistencyScore(activeDates, timeZone),
+  );
+}
+
+export async function GET(req: NextRequest) {
+  const session = await getServerSession(authOptions);
+  if (!session?.accessToken || !session.githubLogin || !session.githubId) {
+    return Response.json({ error: "Unauthorized" }, { status: 401 });
+  }
+
+  const accountId = req.nextUrl.searchParams.get("accountId");
+  const bypass = isMetricsCacheBypassed(req);
+
+  const userRow = await resolveAppUser(session.githubId, session.githubLogin);
+  const appUserId = userRow?.id ?? null;
+
+  if (accountId && !appUserId) {
+    return Response.json({ error: "Unauthorized" }, { status: 401 });
+  }
+
+  let timeZone = "UTC";
+  if (appUserId) {
+    const { data: tzRow } = await supabaseAdmin
+      .from("users")
+      .select("timezone")
+      .eq("id", appUserId)
+      .single();
+    if (tzRow?.timezone) timeZone = tzRow.timezone;
+  }
+
+  if (!accountId) {
+    try {
+      const activeDates = await fetchActiveDates(
+        session.githubLogin,
+        session.accessToken,
+        { bypass, userId: session.githubId },
+        timeZone,
+      );
+      const result = await getConsistencyScoreForDates(activeDates, timeZone, {
+        bypass,
+        userId: session.githubId,
+        accountKey: "default",
+      });
+      return Response.json(result);
+    } catch {
+      return Response.json({ error: "GitHub API error" }, { status: 502 });
+    }
+  }
+
+  if (!appUserId) {
+    return Response.json({ error: "Unauthorized" }, { status: 401 });
+  }
+
+  if (accountId === "combined") {
+    const accounts = await getAllAccounts(
+      {
+        token: session.accessToken,
+        githubId: session.githubId,
+        githubLogin: session.githubLogin,
+      },
+      appUserId,
+    );
+
+    const dateResults = await Promise.allSettled(
+      accounts.map((account) =>
+        fetchActiveDates(
+          account.githubLogin,
+          account.token,
+          { bypass, userId: account.githubId },
+          timeZone,
+        ),
+      ),
+    );
+
+    const unifiedDates = new Set<string>();
+    for (const result of dateResults) {
+      if (result.status === "fulfilled") {
+        result.value.forEach((date) => unifiedDates.add(date));
+      }
+    }
+
+    const scoreData = await getConsistencyScoreForDates(unifiedDates, timeZone, {
+      bypass,
+      userId: appUserId,
+      accountKey: "combined",
+    });
+
+    return Response.json(scoreData);
+  }
+
+  let resolvedToken = session.accessToken;
+  let resolvedLogin = session.githubLogin;
+
+  if (accountId !== session.githubId) {
+    const accountToken = await getAccountToken(appUserId, accountId);
+
+    if (!accountToken) {
+      return Response.json({ error: "Account not found" }, { status: 404 });
+    }
+
+    const { data: accountRow } = await supabaseAdmin
+      .from("user_github_accounts")
+      .select("github_login")
+      .eq("user_id", appUserId)
+      .eq("github_id", accountId)
+      .single();
+
+    if (!accountRow?.github_login) {
+      return Response.json({ error: "Account not found" }, { status: 404 });
+    }
+
+    resolvedToken = accountToken;
+    resolvedLogin = accountRow.github_login;
+  }
+
+  try {
+    const activeDates = await fetchActiveDates(
+      resolvedLogin,
+      resolvedToken,
+      { bypass, userId: accountId },
+      timeZone,
+    );
+    const result = await getConsistencyScoreForDates(activeDates, timeZone, {
+      bypass,
+      userId: accountId,
+      accountKey: accountId,
+    });
+    return Response.json(result);
+  } catch {
+    return Response.json({ error: "GitHub API error" }, { status: 502 });
+  }
+}
diff --git a/src/components/ConsistencyScoreWidget.tsx b/src/components/ConsistencyScoreWidget.tsx
new file mode 100644
index 00000000..921c2b23
--- /dev/null
+++ b/src/components/ConsistencyScoreWidget.tsx
@@ -0,0 +1,253 @@
+"use client";
+
+import { useCallback, useEffect, useState } from "react";
+import {
+  Bar,
+  BarChart,
+  CartesianGrid,
+  ResponsiveContainer,
+  Tooltip,
+  XAxis,
+  YAxis,
+} from "recharts";
+import SectionHeader from "@/components/SectionHeader";
+import { useAccount } from "@/components/AccountContext";
+import {
+  isRecentlyActiveFromScore,
+  type ConsistencyScoreResult,
+} from "@/lib/consistency-score";
+
+const GRADE_COLORS: Record<ConsistencyScoreResult["grade"], string> = {
+  S: "bg-emerald-500/15 text-emerald-400 border-emerald-500/30",
+  A: "bg-blue-500/15 text-blue-400 border-blue-500/30",
+  B: "bg-yellow-500/15 text-yellow-400 border-yellow-500/30",
+  C: "bg-orange-500/15 text-orange-400 border-orange-500/30",
+  D: "bg-red-500/15 text-red-400 border-red-500/30",
+};
+
+const GRADE_RING_COLORS: Record<ConsistencyScoreResult["grade"], string> = {
+  S: "var(--success, #10b981)",
+  A: "#3b82f6",
+  B: "#eab308",
+  C: "#f97316",
+  D: "var(--destructive, #ef4444)",
+};
+
+function CircularProgress({
+  score,
+  grade,
+}: {
+  score: number;
+  grade: ConsistencyScoreResult["grade"];
+}) {
+  const radius = 52;
+  const circumference = 2 * Math.PI * radius;
+  const offset = circumference - (score / 100) * circumference;
+  const strokeColor = GRADE_RING_COLORS[grade];
+
+  return (
+    <div className="relative flex h-32 w-32 items-center justify-center">
+      <svg className="h-32 w-32 -rotate-90" viewBox="0 0 120 120" aria-hidden="true">
+        <circle
+          cx="60"
+          cy="60"
+          r={radius}
+          fill="none"
+          stroke="var(--control)"
+          strokeWidth="10"
+        />
+        <circle
+          cx="60"
+          cy="60"
+          r={radius}
+          fill="none"
+          stroke={strokeColor}
+          strokeWidth="10"
+          strokeLinecap="round"
+          strokeDasharray={circumference}
+          strokeDashoffset={offset}
+          className="transition-all duration-700 ease-out"
+        />
+      </svg>
+      <div className="absolute inset-0 flex flex-col items-center justify-center">
+        <span className="text-3xl font-bold text-[var(--card-foreground)]">{score}</span>
+        <span className="text-xs text-[var(--muted-foreground)]">/ 100</span>
+      </div>
+    </div>
+  );
+}
+
+function ConsistencyScoreSkeleton() {
+  return (
+    <div
+      role="status"
+      aria-busy="true"
+      aria-label="Loading consistency score"
+      className="rounded-xl border border-[var(--border)] bg-[var(--card)] p-6 shadow-sm flex flex-col h-full"
+    >
+      <div className="h-6 w-40 bg-[var(--card-muted)] rounded mb-6 animate-pulse" aria-hidden="true" />
+      <div className="flex justify-center mb-6" aria-hidden="true">
+        <div className="h-32 w-32 rounded-full bg-[var(--card-muted)] animate-pulse" />
+      </div>
+      <div className="grid grid-cols-2 gap-4 mb-6" aria-hidden="true">
+        {[1, 2, 3, 4].map((i) => (
+          <div key={i} className="h-20 bg-[var(--card-muted)] rounded-lg animate-pulse" />
+        ))}
+      </div>
+      <div className="h-40 w-full bg-[var(--card-muted)] rounded-lg animate-pulse" aria-hidden="true" />
+    </div>
+  );
+}
+
+export default function ConsistencyScoreWidget() {
+  const { selectedAccount } = useAccount();
+  const [data, setData] = useState<ConsistencyScoreResult | null>(null);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<string | null>(null);
+
+  const fetchScore = useCallback(async () => {
+    setLoading(true);
+    setError(null);
+
+    try {
+      const url =
+        selectedAccount !== null
+          ? `/api/metrics/consistency-score?accountId=${encodeURIComponent(selectedAccount)}`
+          : "/api/metrics/consistency-score";
+      const res = await fetch(url);
+
+      if (!res.ok) {
+        throw new Error("Failed to fetch consistency score");
+      }
+
+      const json = (await res.json()) as ConsistencyScoreResult;
+      setData(json);
+    } catch (err) {
+      console.error("Failed to fetch consistency score:", err);
+      setError("We couldn't load your consistency score right now. Please try again in a moment.");
+    } finally {
+      setLoading(false);
+    }
+  }, [selectedAccount]);
+
+  useEffect(() => {
+    fetchScore();
+  }, [fetchScore]);
+
+  useEffect(() => {
+    const handleSync = () => {
+      fetchScore();
+    };
+    window.addEventListener("devtrack:sync", handleSync);
+    return () => window.removeEventListener("devtrack:sync", handleSync);
+  }, [fetchScore]);
+
+  if (loading) {
+    return <ConsistencyScoreSkeleton />;
+  }
+
+  if (error) {
+    return (
+      <div className="rounded-xl border border-[var(--border)] bg-[var(--card)] p-6 shadow-sm">
+        <SectionHeader title="Consistency Score" />
+        <div className="rounded-lg border border-[var(--destructive)]/20 bg-[var(--destructive)]/10 p-4 text-sm text-[var(--destructive)]">
+          <p>{error}</p>
+          <button
+            type="button"
+            onClick={fetchScore}
+            className="mt-3 rounded-md border border-[var(--destructive)]/30 px-3 py-1.5 text-xs font-medium text-[var(--destructive)] transition-colors hover:bg-[var(--destructive)]/10"
+          >
+            Try again
+          </button>
+        </div>
+      </div>
+    );
+  }
+
+  if (!data) {
+    return null;
+  }
+
+  const stats = [
+    {
+      label: "Weekly Consistency",
+      value: `${data.weeklyConsistency}%`,
+    },
+    {
+      label: "Streak Quality",
+      value: `${Math.round(data.streakQuality * 100)}%`,
+    },
+    {
+      label: "Longest Gap",
+      value: `${data.longestGap} days`,
+    },
+    {
+      label: "Recent Activity",
+      value: isRecentlyActiveFromScore(data) ? "Active" : "Inactive",
+    },
+  ];
+
+  return (
+    <div className="rounded-xl border border-[var(--border)] bg-[var(--card)] p-6 shadow-sm">
+      <div className="mb-4 flex items-center justify-between">
+        <SectionHeader title="Consistency Score" />
+        <span
+          className={`inline-flex items-center rounded-full border px-3 py-1 text-sm font-bold ${GRADE_COLORS[data.grade]}`}
+        >
+          {data.grade}
+        </span>
+      </div>
+
+      <div className="mb-6 flex justify-center">
+        <CircularProgress score={data.score} grade={data.grade} />
+      </div>
+
+      <div className="mb-6 grid grid-cols-2 gap-3">
+        {stats.map((stat) => (
+          <div
+            key={stat.label}
+            className="rounded-lg bg-[var(--control)] p-4 text-center"
+          >
+            <div className="text-lg font-bold text-[var(--accent)]">{stat.value}</div>
+            <div className="mt-1 text-xs text-[var(--muted-foreground)]">{stat.label}</div>
+          </div>
+        ))}
+      </div>
+
+      <div className="mb-4 h-44 w-full">
+        <ResponsiveContainer width="100%" height="100%">
+          <BarChart data={data.monthlyTrend} margin={{ top: 4, right: 4, left: -16, bottom: 0 }}>
+            <CartesianGrid strokeDasharray="3 3" stroke="var(--border)" vertical={false} />
+            <XAxis
+              dataKey="month"
+              tick={{ fontSize: 11, fill: "var(--muted-foreground)" }}
+              axisLine={false}
+              tickLine={false}
+            />
+            <YAxis
+              allowDecimals={false}
+              tick={{ fontSize: 11, fill: "var(--muted-foreground)" }}
+              axisLine={false}
+              tickLine={false}
+            />
+            <Tooltip
+              cursor={{ fill: "var(--control)" }}
+              contentStyle={{
+                backgroundColor: "var(--card)",
+                borderColor: "var(--border)",
+                borderRadius: "8px",
+                color: "var(--card-foreground)",
+              }}
+              formatter={(value: number) => [`${value} days`, "Active Days"]}
+            />
+            <Bar dataKey="activeDays" fill="var(--accent)" radius={[4, 4, 0, 0]} />
+          </BarChart>
+        </ResponsiveContainer>
+      </div>
+
+      <div className="rounded-lg border border-[var(--border)] bg-[var(--control)] px-4 py-3 text-sm text-[var(--muted-foreground)]">
+        {data.improvementTip}
+      </div>
+    </div>
+  );
+}
diff --git a/src/components/dashboard/CustomizableDashboard.tsx b/src/components/dashboard/CustomizableDashboard.tsx
index 95353860..ac3f4da8 100644
--- a/src/components/dashboard/CustomizableDashboard.tsx
+++ b/src/components/dashboard/CustomizableDashboard.tsx
@@ -25,6 +25,7 @@ import DiscussionsWidget from "@/components/DiscussionsWidget";
 import CommunityMetrics from "@/components/CommunityMetrics";
 import GoalTracker from "@/components/GoalTracker";
 import StreakTracker from "@/components/StreakTracker";
+import ConsistencyScoreWidget from "@/components/ConsistencyScoreWidget";
 import TopRepos from "@/components/TopRepos";
 import PinnedReposWidget from "@/components/PinnedReposWidget";
 import InactiveRepositoriesCard from "@/components/InactiveRepositoriesCard";
@@ -298,6 +299,13 @@ const renderDashboardWidget = (widgetId: DashboardWidgetId): ReactNode => {
     case "streak-tracker":
       return <StreakTracker />;
 
+    case "consistency-score":
+      return (
+        <LazyWidget fallback={<ChartSkeleton />}>
+          <ConsistencyScoreWidget />
+        </LazyWidget>
+      );
+
     case "local-coding-time":
       return <LocalCodingTime />;
 
diff --git a/src/lib/consistency-score.ts b/src/lib/consistency-score.ts
new file mode 100644
index 00000000..ab1e6318
--- /dev/null
+++ b/src/lib/consistency-score.ts
@@ -0,0 +1,180 @@
+import { format, parseISO, startOfWeek, subMonths, subWeeks } from "date-fns";
+import { dateDiffDays } from "@/lib/dateUtils";
+import { calculateStreakFromDates } from "@/lib/streak";
+
+export interface ConsistencyScoreResult {
+  score: number;
+  grade: "S" | "A" | "B" | "C" | "D";
+  weeklyConsistency: number;
+  monthlyTrend: { month: string; activeDays: number }[];
+  longestGap: number;
+  avgDailyCommits: number;
+  streakQuality: number;
+  improvementTip: string;
+}
+
+function todayInTimezone(timeZone: string): string {
+  const parts = new Intl.DateTimeFormat("en", {
+    timeZone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+  }).formatToParts(new Date());
+  const year = parts.find((p) => p.type === "year")?.value;
+  const month = parts.find((p) => p.type === "month")?.value;
+  const day = parts.find((p) => p.type === "day")?.value;
+  return `${year}-${month}-${day}`;
+}
+
+function mondayOfWeek(dateStr: string): string {
+  const monday = startOfWeek(parseISO(dateStr), { weekStartsOn: 1 });
+  return format(monday, "yyyy-MM-dd");
+}
+
+function hasActivityInLastNDays(
+  activeDates: Set<string>,
+  days: number,
+  today: string,
+): boolean {
+  for (const dateStr of activeDates) {
+    const diff = dateDiffDays(dateStr, today);
+    if (diff >= 0 && diff < days) {
+      return true;
+    }
+  }
+  return false;
+}
+
+function computeWeeklyConsistency(activeDates: Set<string>): number {
+  const activeWeeks = new Set<string>();
+  for (const dateStr of activeDates) {
+    activeWeeks.add(mondayOfWeek(dateStr));
+  }
+
+  const thisWeekStart = startOfWeek(new Date(), { weekStartsOn: 1 });
+  let weeksWithActivity = 0;
+
+  for (let i = 0; i < 12; i += 1) {
+    const weekStart = format(subWeeks(thisWeekStart, i), "yyyy-MM-dd");
+    if (activeWeeks.has(weekStart)) {
+      weeksWithActivity += 1;
+    }
+  }
+
+  return Math.round((weeksWithActivity / 12) * 100);
+}
+
+function computeMonthlyTrend(
+  activeDates: Set<string>,
+): { month: string; activeDays: number }[] {
+  const trend: { month: string; activeDays: number }[] = [];
+
+  for (let i = 5; i >= 0; i -= 1) {
+    const monthDate = subMonths(new Date(), i);
+    const monthKey = format(monthDate, "yyyy-MM");
+    const monthLabel = format(monthDate, "MMM yyyy");
+    let activeDays = 0;
+
+    for (const dateStr of activeDates) {
+      if (dateStr.startsWith(monthKey)) {
+        activeDays += 1;
+      }
+    }
+
+    trend.push({ month: monthLabel, activeDays });
+  }
+
+  return trend;
+}
+
+function computeLongestGap(sortedDates: string[]): number {
+  if (sortedDates.length < 2) {
+    return 0;
+  }
+
+  let longestGap = 0;
+  for (let i = 1; i < sortedDates.length; i += 1) {
+    const gap = dateDiffDays(sortedDates[i - 1], sortedDates[i]) - 1;
+    longestGap = Math.max(longestGap, Math.max(0, gap));
+  }
+
+  return longestGap;
+}
+
+function scoreToGrade(score: number): ConsistencyScoreResult["grade"] {
+  if (score >= 90) return "S";
+  if (score >= 75) return "A";
+  if (score >= 60) return "B";
+  if (score >= 40) return "C";
+  return "D";
+}
+
+function getImprovementTip(score: number): string {
+  if (score < 40) {
+    return "Try committing at least once every 2-3 days to build consistency";
+  }
+  if (score < 60) {
+    return "You are making progress! Aim for 4+ active days per week";
+  }
+  if (score < 75) {
+    return "Good consistency! Try to reduce gaps between coding sessions";
+  }
+  if (score < 90) {
+    return "Great work! Maintain your current streak to reach S tier";
+  }
+  return "Outstanding consistency! You are in the top tier of developers";
+}
+
+export function calculateConsistencyScore(
+  activeDates: Set<string>,
+  timeZone = "UTC",
+): ConsistencyScoreResult {
+  const sortedDates = Array.from(activeDates).sort();
+  const today = todayInTimezone(timeZone);
+
+  const weeklyConsistency = computeWeeklyConsistency(activeDates);
+  const monthlyTrend = computeMonthlyTrend(activeDates);
+  const longestGap = computeLongestGap(sortedDates);
+
+  const streak = calculateStreakFromDates(activeDates, new Set(), timeZone);
+  const streakQuality =
+    streak.longest > 0 ? streak.current / streak.longest : 0;
+
+  const avgDailyCommits = sortedDates.length > 0 ? 1 : 0;
+
+  const weeklyPoints = (weeklyConsistency / 100) * 40;
+  const streakPoints = streakQuality * 30;
+  const gapPoints = 20 - Math.min(20, longestGap / 7);
+
+  let recentPoints = 0;
+  if (hasActivityInLastNDays(activeDates, 7, today)) {
+    recentPoints = 10;
+  } else if (hasActivityInLastNDays(activeDates, 14, today)) {
+    recentPoints = 5;
+  }
+
+  const score = Math.round(
+    Math.min(100, Math.max(0, weeklyPoints + streakPoints + gapPoints + recentPoints)),
+  );
+
+  return {
+    score,
+    grade: scoreToGrade(score),
+    weeklyConsistency,
+    monthlyTrend,
+    longestGap,
+    avgDailyCommits,
+    streakQuality,
+    improvementTip: getImprovementTip(score),
+  };
+}
+
+export function isRecentlyActiveFromScore(data: ConsistencyScoreResult): boolean {
+  const weeklyPoints = (data.weeklyConsistency / 100) * 40;
+  const streakPoints = data.streakQuality * 30;
+  const gapPoints = 20 - Math.min(20, data.longestGap / 7);
+  const withoutRecent = Math.round(
+    Math.min(100, Math.max(0, weeklyPoints + streakPoints + gapPoints)),
+  );
+  return data.score - withoutRecent >= 10;
+}
diff --git a/src/lib/dashboard-layout.ts b/src/lib/dashboard-layout.ts
index ce338bec..4d202a03 100644
--- a/src/lib/dashboard-layout.ts
+++ b/src/lib/dashboard-layout.ts
@@ -16,6 +16,7 @@ export type DashboardWidgetId =
   | "activity-ring"
   | "coding-activity-insights"
   | "streak-tracker"
+  | "consistency-score"
   | "local-coding-time"
   | "coding-time"
   | "commit-time"
@@ -69,6 +70,7 @@ export const DASHBOARD_WIDGET_LABELS: Record<DashboardWidgetId, string> = {
   "activity-ring": "Activity Ring",
   "coding-activity-insights": "Coding Activity Insights",
   "streak-tracker": "Streak Tracker",
+  "consistency-score": "Consistency Score",
   "local-coding-time": "Local Coding Time",
   "coding-time": "Coding Time",
   "commit-time": "Commit Time",
@@ -104,6 +106,7 @@ export const DEFAULT_DASHBOARD_LAYOUT: DashboardLayoutPreference = {
       "activity-ring",
       "coding-activity-insights",
       "streak-tracker",
+      "consistency-score",
       "local-coding-time",
       "coding-time",
       "commit-time",