From 10dae8d2ed2bed790eb15436eeb8421c7f3e20b2 Mon Sep 17 00:00:00 2001
From: Alberto Monterroso <14013679+Albermonte@users.noreply.github.com>
Date: Fri, 31 Jul 2026 13:50:30 +0200
Subject: [PATCH 1/4] feat(scores): add hybrid v2 score rollout

Add marker-gated activity synchronization and independent v1/v2 score persistence. Expose score-version selection across the API and dashboard with freshness states, recovery logging, migrations, tests, and rollout documentation.
---
 .env.example                                  |    7 +
 MIGRATION.md                                  |   71 +-
 README.md                                     |   63 +-
 app/app.vue                                   |  144 ++-
 app/components/ScorePie.vue                   |    6 +-
 app/components/ScorePies.vue                  |   95 +-
 app/components/ScoreVersionSelect.vue         |   35 +
 app/components/ValidatorsTable.vue            |   49 +-
 app/components/validator/LayoutDashboard.vue  |   15 +-
 app/components/validator/LayoutDeepDive.vue   |   41 +-
 app/components/validator/LayoutProfile.vue    |   11 +-
 app/composables/useScoreVersionQuery.ts       |   30 +
 app/composables/useValidatorCharts.test.ts    |   78 +-
 app/composables/useValidatorCharts.ts         |  144 ++-
 app/pages/index.vue                           |   37 +-
 app/pages/validator/[address].vue             |    5 +-
 app/utils/score-display.test.ts               |   65 +
 app/utils/score-display.ts                    |   48 +
 app/utils/score-version.test.ts               |   41 +
 app/utils/score-version.ts                    |   32 +
 ...-activity-integrity-hybrid-score-design.md |  280 +++++
 nuxt.config.test.ts                           |   28 +
 nuxt.config.ts                                |   20 +-
 package.json                                  |    8 +-
 .../build.config.ts                           |    1 +
 .../nimiq-validator-trustscore/package.json   |    4 +
 .../src/fetcher.test.ts                       |  177 +++
 .../nimiq-validator-trustscore/src/fetcher.ts |  116 +-
 .../src/score-v2.test.ts                      |  269 ++++
 .../src/score-v2.ts                           |  255 ++++
 .../nimiq-validator-trustscore/src/types.ts   |   33 +
 server/api/[version]/status.get.test.ts       |  131 ++
 server/api/[version]/status.get.ts            |  108 +-
 .../api/[version]/validators/[address].get.ts |   35 +-
 server/api/[version]/validators/index.get.ts  |   30 +-
 ..._validator_activity_integrity_score_v2.sql |   55 +
 server/db/migrations/meta/0003_snapshot.json  |  405 ++++++
 server/db/migrations/meta/0004_snapshot.json  |  412 ++++++
 server/db/migrations/meta/0005_snapshot.json  |  578 +++++++++
 server/db/migrations/meta/_journal.json       |   21 +
 .../migrations/migrations.integration.test.ts |  126 ++
 server/db/schema.ts                           |   61 +-
 server/tasks/cron/sync.test.ts                |  114 ++
 server/tasks/cron/sync.ts                     |   30 +-
 server/tasks/sync/epochs.test.ts              |  166 +++
 server/tasks/sync/epochs.ts                   |  143 ++-
 server/tasks/sync/scores.test.ts              |  114 ++
 server/tasks/sync/scores.ts                   |   57 +
 server/tasks/sync/snapshot.test.ts            |   97 ++
 server/tasks/sync/snapshot.ts                 |   24 +-
 server/test/db-harness.ts                     |  159 +++
 server/utils/activities.ts                    |  325 ++++-
 server/utils/activity-completeness.test.ts    |   38 -
 server/utils/activity-completeness.ts         |   17 -
 server/utils/activity-epochs.test.ts          |  331 +++++
 server/utils/activity-epochs.ts               |  499 ++++++++
 server/utils/activity-integrity.test.ts       |   83 ++
 server/utils/activity-integrity.ts            |   43 +
 .../activity-persistence.integration.test.ts  | 1108 +++++++++++++++++
 server/utils/activity-sync.test.ts            |  194 +++
 server/utils/activity-sync.ts                 |  144 +++
 server/utils/cron-task-runner.test.ts         |   26 +
 server/utils/cron-task-runner.ts              |   57 +
 server/utils/drizzle.ts                       |    5 +-
 server/utils/schemas.ts                       |    2 +
 server/utils/score-api.test.ts                |  276 ++++
 server/utils/score-api.ts                     |  183 +++
 server/utils/scores.integration.test.ts       |  647 ++++++++++
 server/utils/scores.test.ts                   |  160 +++
 server/utils/scores.ts                        |  825 ++++++++++--
 server/utils/slack.ts                         |    2 +-
 server/utils/types.ts                         |   25 +-
 server/utils/validators.integration.test.ts   |  143 +++
 server/utils/validators.ts                    |  113 +-
 vitest.config.ts                              |    5 +
 wrangler.json                                 |    8 +-
 76 files changed, 9854 insertions(+), 479 deletions(-)
 create mode 100644 app/components/ScoreVersionSelect.vue
 create mode 100644 app/composables/useScoreVersionQuery.ts
 create mode 100644 app/utils/score-display.test.ts
 create mode 100644 app/utils/score-display.ts
 create mode 100644 app/utils/score-version.test.ts
 create mode 100644 app/utils/score-version.ts
 create mode 100644 docs/superpowers/specs/2026-07-28-validator-activity-integrity-hybrid-score-design.md
 create mode 100644 nuxt.config.test.ts
 create mode 100644 packages/nimiq-validator-trustscore/src/fetcher.test.ts
 create mode 100644 packages/nimiq-validator-trustscore/src/score-v2.test.ts
 create mode 100644 packages/nimiq-validator-trustscore/src/score-v2.ts
 create mode 100644 server/api/[version]/status.get.test.ts
 create mode 100644 server/db/migrations/0005_validator_activity_integrity_score_v2.sql
 create mode 100644 server/db/migrations/meta/0003_snapshot.json
 create mode 100644 server/db/migrations/meta/0004_snapshot.json
 create mode 100644 server/db/migrations/meta/0005_snapshot.json
 create mode 100644 server/db/migrations/migrations.integration.test.ts
 create mode 100644 server/tasks/cron/sync.test.ts
 create mode 100644 server/tasks/sync/epochs.test.ts
 create mode 100644 server/tasks/sync/scores.test.ts
 create mode 100644 server/tasks/sync/scores.ts
 create mode 100644 server/tasks/sync/snapshot.test.ts
 create mode 100644 server/test/db-harness.ts
 delete mode 100644 server/utils/activity-completeness.test.ts
 delete mode 100644 server/utils/activity-completeness.ts
 create mode 100644 server/utils/activity-epochs.test.ts
 create mode 100644 server/utils/activity-epochs.ts
 create mode 100644 server/utils/activity-integrity.test.ts
 create mode 100644 server/utils/activity-integrity.ts
 create mode 100644 server/utils/activity-persistence.integration.test.ts
 create mode 100644 server/utils/activity-sync.test.ts
 create mode 100644 server/utils/activity-sync.ts
 create mode 100644 server/utils/cron-task-runner.test.ts
 create mode 100644 server/utils/cron-task-runner.ts
 create mode 100644 server/utils/score-api.test.ts
 create mode 100644 server/utils/score-api.ts
 create mode 100644 server/utils/scores.integration.test.ts
 create mode 100644 server/utils/scores.test.ts
 create mode 100644 server/utils/validators.integration.test.ts

diff --git a/.env.example b/.env.example
index 0e0e752d..3239b593 100644
--- a/.env.example
+++ b/.env.example
@@ -3,3 +3,10 @@
 
 NUXT_PUBLIC_NIMIQ_NETWORK=test-albatross
 ALBATROSS_RPC_NODE_URL=
+# off: v1 only; shadow: write v1/v2, serve v1; active: write v1/v2, serve v2
+NUXT_SCORE_V2_MODE=off
+
+# Migration-only NuxtHub D1 HTTP credentials. Keep out of deployed runtime vars.
+NUXT_HUB_CLOUDFLARE_ACCOUNT_ID=
+NUXT_HUB_CLOUDFLARE_DATABASE_ID=
+NUXT_HUB_CLOUDFLARE_API_TOKEN=
diff --git a/MIGRATION.md b/MIGRATION.md
index 00546a97..f996e094 100644
--- a/MIGRATION.md
+++ b/MIGRATION.md
@@ -2,7 +2,7 @@
 
 ## Background
 
-Cloudflare Pages does NOT support scheduled tasks (cron jobs). This project requires hourly syncing, so we migrated to Cloudflare Workers.
+Cloudflare Pages does not support scheduled tasks. This project requires six-hour syncing, so it uses Cloudflare Workers.
 
 ## Setting Up Redirects
 
@@ -60,3 +60,72 @@ curl -I https://validators-api-testnet.pages.dev/api/v1/status
 2. Deploy redirects to Pages projects
 3. Monitor for 1-2 weeks
 4. (Optional) Deprecate legacy `.pages.dev` URLs and add a custom domain
+
+## Activity integrity and score v2 rollout
+
+This implementation does not perform any remote migration or deployment. Run each remote command manually, testnet first, after reviewing its target.
+
+### Safeguards
+
+1. Authenticate Wrangler and confirm the expected account:
+
+   ```bash
+   pnpm exec wrangler login
+   pnpm exec wrangler whoami
+   ```
+
+2. Inspect applied migrations and relevant table/index definitions. Never assume a migration is already applied:
+
+   ```bash
+   pnpm exec wrangler d1 execute validators-api-testnet --remote --env testnet --command "SELECT id, name, applied_at FROM _hub_migrations ORDER BY id;"
+   pnpm exec wrangler d1 execute validators-api-testnet --remote --env testnet --command "SELECT name, type, sql FROM sqlite_schema WHERE name IN ('_hub_migrations', 'activities', 'activity_epochs', 'scores', 'validators') OR name LIKE 'idx_%' ORDER BY type, name;"
+   ```
+
+3. Export a backup outside this repository:
+
+   ```bash
+   pnpm exec wrangler d1 export validators-api-testnet --remote --env testnet --output ../validators-api-testnet-before-score-v2.sql
+   ```
+
+4. Put migration-only D1 HTTP credentials in `.env.testnet`:
+
+   ```dotenv
+   NUXT_HUB_CLOUDFLARE_ACCOUNT_ID=...
+   NUXT_HUB_CLOUDFLARE_DATABASE_ID=...
+   NUXT_HUB_CLOUDFLARE_API_TOKEN=...
+   ```
+
+   Keep these values out of deployed runtime variables. Migration scripts enable the HTTP driver only for their own command and fail if any credential is missing.
+
+Repeat inspection and backup with `validators-api-mainnet` and without `--env testnet` only after testnet validation passes.
+
+### Testnet-first sequence
+
+1. Keep testnet `NUXT_SCORE_V2_MODE=off`.
+2. Apply all pending tracked migrations:
+
+   ```bash
+   pnpm db:migrate:testnet
+   ```
+
+   This uses NuxtHub's basename-compatible `_hub_migrations` ledger. Do not substitute `wrangler d1 migrations apply`; Wrangler records full filenames and can replay an existing NuxtHub baseline.
+
+3. Inspect `_hub_migrations` and relevant schemas again.
+4. Deploy testnet while v2 remains off.
+5. Let the six-hour job discover epochs, repair recent activity, store the snapshot, then calculate v1 scores.
+6. Set `NUXT_SCORE_V2_MODE=shadow`, deploy, and validate v1/v2 rows, activity coverage, score versions, and `current`, `stale`, or `no_score` API states.
+7. Set `NUXT_SCORE_V2_MODE=active` only after shadow results pass.
+8. Repeat the same inspect, backup, migrate, off, repair, shadow, validate, and active sequence for mainnet.
+
+Activity marker interpretation during validation:
+
+- `syncing`: repair attempt is inside its six-hour lease.
+- `complete`: stored `finalized` marker has an exact elected set and matching counts.
+- `incomplete`: expected activity has no valid finalized marker.
+- `failed`: attempt rolled back and recorded an error for retry.
+
+API list, detail, and status endpoints accept `score-version=1|2`. Omitted version follows rollout mode: `off` and `shadow` select v1; `active` selects v2. Selected-version rows are filtered before latest-score selection. `current` means latest completed epoch is covered, `stale` preserves an older valid score, and `no_score` returns null score values.
+
+### Rollback
+
+Set `NUXT_SCORE_V2_MODE=off`, deploy the configuration change, and request `score-version=1` explicitly while caches settle. Keep both v1 and v2 rows intact. Do not roll back schema or score data destructively.
diff --git a/README.md b/README.md
index 93d47c8e..a3421053 100644
--- a/README.md
+++ b/README.md
@@ -113,8 +113,17 @@ The Validators API provides endpoints to retrieve validator information for inte
 | -------------------------------------------------------------------------------- | ------------------------------------------------------------------------------- |
 | [/api/v1/validators](https://validators-api-main.je-cf9.workers.dev/api/v1/validators) | Retrieves the validator list. See [query params](./server/utils/schemas.ts#L54) |
 | [/api/v1/validators/:validator_address](https://validators-api-main.je-cf9.workers.dev/api/v1/validators/NQ98%20D3KE%208EQ8%20Y7DK%20G1MT%203P5T%202PHX%2018V5%20UEC1) | Retrieves the validator information |
+| [/api/v1/status](https://validators-api-main.je-cf9.workers.dev/api/v1/status) | Retrieves activity coverage and selected score status |
 | [/api/v1/supply](https://validators-api-main.je-cf9.workers.dev/api/v1/supply) | Retrieves supply status |
 
+Validator list, detail, and status endpoints accept `score-version=1|2`. Without it, `NUXT_SCORE_V2_MODE=off` and `shadow` select v1, while `active` selects v2. Queries filter by the selected version before choosing the latest score, so responses never mix v1 and v2 history.
+
+Every score includes its version and data state:
+
+- `current`: selected-version score covers the latest completed epoch.
+- `stale`: an older valid score remains available while current activity or scoring is incomplete.
+- `no_score`: no selected-version score exists; numeric fields remain `null`, not zero.
+
 ## Validators Dashboard
 
 The Validators Dashboard is a simple Nuxt application that displays all validators along with their scores. You can access the dashboard here: https://validators-api-main.je-cf9.workers.dev/
@@ -138,7 +147,18 @@ We also do have an UI component to visualize the range, check the status, and de
 
 ### Fetcher
 
-The fetcher is a process that retrieves data from the Nimiq network and stores it in a D1 database. The fetcher runs every hour and collects data about the validators in two different ways:
+The fetcher retrieves data from the Nimiq network and stores it in D1. It runs every six hours in this order:
+
+1. Discover completed epochs and verify or repair activity snapshots.
+2. Store the current validator snapshot.
+3. Calculate scores from finalized activity markers.
+
+Completed-epoch activity uses marker-backed integrity checks. Operator-facing marker states are:
+
+- `syncing`: repair attempt owns a fresh six-hour lease.
+- `complete`: stored `finalized` marker has matching election-set hash and elected counts.
+- `incomplete`: expected epoch has no finalized marker or exact stored set.
+- `failed`: attempt rolled back and retained its error for retry.
 
 #### Ended epochs
 
@@ -213,44 +233,35 @@ Where `env`: `testnet` (omit `-e env` for mainnet production).
 
 ### D1 Migrations
 
-When adding a new SQL migration under `server/db/migrations/`, apply it to the remote D1 database.
+Never assume remote migration state. Authenticate Wrangler, inspect `_hub_migrations` and relevant schemas, and export a backup outside the repository before applying migrations. Set the migration-only `NUXT_HUB_CLOUDFLARE_ACCOUNT_ID`, `NUXT_HUB_CLOUDFLARE_DATABASE_ID`, and `NUXT_HUB_CLOUDFLARE_API_TOKEN` values in the target `.env` file.
 
-For the `cron_runs` table:
+Generic migration commands use NuxtHub's `_hub_migrations` basenames and apply all pending files under `server/db/migrations/`:
 
 ```bash
-pnpm db:apply:cron-runs:mainnet
+pnpm db:migrate:testnet
+pnpm db:migrate:mainnet
 ```
 
-Testnet:
-
-```bash
-pnpm db:apply:cron-runs:testnet
-```
-
-Required schema:
-
-- `validators.is_listed` must exist in all remote D1 databases.
+Always migrate and validate testnet first. See [MIGRATION.md](./MIGRATION.md) for inspection, backup, rollout, and rollback steps.
 
-If the column is missing, apply it manually:
+This implementation does not run any remote migration or deployment.
 
-Mainnet:
+**Environments** (configured in `wrangler.json`):
 
-```bash
-pnpm db:apply:is-listed:mainnet
-```
+- `production`: [Validators API Mainnet](https://validators-api-main.je-cf9.workers.dev) via manual `wrangler deploy`
+- `testnet`: [Validators API Testnet](https://validators-api-test.je-cf9.workers.dev) via manual `wrangler deploy --env testnet`
 
-Testnet:
+Each environment has its own D1 database, KV cache, and R2 blob. Sync runs every six hours via Cloudflare cron triggers (see `server/tasks/sync/`).
 
-```bash
-pnpm db:apply:is-listed:testnet
-```
+### Score v2 rollout
 
-**Environments** (configured in `wrangler.json`):
+Set `NUXT_SCORE_V2_MODE` per environment:
 
-- `production`: [Validators API Mainnet](https://validators-api-main.je-cf9.workers.dev) via manual `wrangler deploy`
-- `testnet`: [Validators API Testnet](https://validators-api-test.je-cf9.workers.dev) via manual `wrangler deploy --env testnet`
+- `off`: write and serve v1 only.
+- `shadow`: keep v1 writes, also write v2, and serve v1 by default.
+- `active`: keep v1 and v2 writes, and serve v2 by default.
 
-Each environment has its own D1 database, KV cache, and R2 blob. Sync runs every 12 hours via Cloudflare cron triggers (see `server/tasks/sync/`).
+Rollback requires no destructive schema or data change: set `NUXT_SCORE_V2_MODE=off`, keep all v1/v2 rows intact, and request `score-version=1` explicitly while the configuration change propagates.
 
 ### Deployment Migration
 
diff --git a/app/app.vue b/app/app.vue
index f4638cd7..f6ccac13 100644
--- a/app/app.vue
+++ b/app/app.vue
@@ -1,17 +1,93 @@
 <script setup lang="ts">
 import type { EnvItemType } from './utils/environments'
 import { environments, getEnvironmentItem } from './utils/environments'
+import { mergeScoreVersionQuery, resolveDashboardScoreVersion } from './utils/score-version'
 
-const { data: status, status: statusRequest, refresh: refreshStatus, error } = await useFetch('/api/v1/status', { server: true, lazy: false })
+const route = useRoute()
+const { scoreVersionRequestQuery, setScoreVersion } = useScoreVersionQuery()
+const { data: status, status: statusRequest, refresh: refreshStatus, error } = await useFetch('/api/v1/status', {
+  server: true,
+  lazy: false,
+  query: scoreVersionRequestQuery,
+})
+const selectedScoreVersion = computed(() =>
+  resolveDashboardScoreVersion(
+    route.query['score-version'],
+    status.value?.selectedScoreVersion,
+  ),
+)
+const scoreVersionLinkQuery = computed(() =>
+  mergeScoreVersionQuery({}, selectedScoreVersion.value),
+)
 
 const colorMode = useColorMode()
 const toggleDark = () => colorMode.value = colorMode.value === 'light' ? 'dark' : 'light'
 
-const route = useRoute()
 const validatorDetail = computed(() => !!route.params.address)
-const isActivitySync = computed(() => Boolean(status.value?.missingEpochs?.length === 0))
-const isScoreSync = computed(() => status.value?.missingScore === false)
-const isSynced = computed(() => isActivitySync.value && isScoreSync.value)
+
+type HealthKind = 'current' | 'synchronizing' | 'failed' | 'stale' | 'no_score' | 'live_unavailable'
+
+const health = computed<{ kind: HealthKind, label: string }>(() => {
+  if (statusRequest.value === 'pending')
+    return { kind: 'synchronizing', label: 'Synchronizing' }
+  if (error.value || status.value?.failedEpochs.length)
+    return { kind: 'failed', label: 'Failed' }
+  if (status.value?.syncingEpochs.length)
+    return { kind: 'synchronizing', label: 'Synchronizing' }
+  if (!status.value?.range)
+    return { kind: 'live_unavailable', label: 'Live unavailable' }
+  if (status.value.scoreStatus === 'no_score')
+    return { kind: 'no_score', label: 'No score' }
+  if (
+    status.value.recentCoverage !== 1
+    || status.value.longTermCoverage !== 1
+    || status.value.scoreStatus === 'stale'
+  ) {
+    return { kind: 'stale', label: 'Stale' }
+  }
+  return { kind: 'current', label: 'Current' }
+})
+
+const healthClasses = computed(() => {
+  if (health.value.kind === 'current') {
+    return {
+      container: 'outline-green-500 text-green-1100',
+      badge: 'bg-green-400',
+    }
+  }
+  if (health.value.kind === 'synchronizing' || health.value.kind === 'live_unavailable') {
+    return {
+      container: 'outline-neutral-400 text-neutral-800',
+      badge: 'bg-neutral-400',
+    }
+  }
+  return {
+    container: 'outline-red-500 text-red-1100',
+    badge: 'bg-red-400',
+  }
+})
+
+const healthDetails = computed(() => {
+  const details: string[] = []
+  if (error.value)
+    details.push('Status request failed.')
+  if (!status.value)
+    return details
+  if (!status.value.range)
+    details.push('Live blockchain range is unavailable. Stored synchronization state is shown.')
+  if (status.value.failedEpochs.length)
+    details.push(`Failed activity epochs: ${status.value.failedEpochs.map(epoch => epoch.epochNumber).join(', ')}.`)
+  if (status.value.syncingEpochs.length)
+    details.push(`Synchronizing activity epochs: ${status.value.syncingEpochs.map(epoch => epoch.epochNumber).join(', ')}.`)
+  details.push(`Recent activity coverage: ${status.value.recentCoverage === null ? 'unavailable' : percentageFormatter.format(status.value.recentCoverage)}.`)
+  details.push(`Long-term activity coverage: ${status.value.longTermCoverage === null ? 'unavailable' : percentageFormatter.format(status.value.longTermCoverage)}.`)
+  details.push(`Score v${status.value.selectedScoreVersion}: ${status.value.scoreStatus.replace('_', ' ')}.`)
+  return details
+})
+
+const showHealthWarning = computed(() =>
+  statusRequest.value !== 'pending' && (health.value.kind !== 'current' || Boolean(error.value)),
+)
 
 const { nimiqNetwork } = useSafeRuntimeConfig().public
 const [DefineEnvItem, EnvItem] = createReusableTemplate<{ item: EnvItemType, component: string }>()
@@ -30,16 +106,34 @@ const currentEnvItem = getEnvironmentItem(nimiqNetwork) ?? { network: nimiqNetwo
   </DefineEnvItem>
 
   <div flex="~ col gap-64" mx-auto size-screen max-h-screen max-w-1200 px-32 py-20>
-    <header flex="~ gap-32 row items-center">
-      <NuxtLink to="/" flex>
+    <header flex="~ gap-32 row items-center" class="max-sm:flex-wrap max-sm:gap-12">
+      <NuxtLink
+        :to="{
+          path: '/',
+          query: scoreVersionLinkQuery,
+        }"
+        flex
+      >
         <div aria-hidden class="i-nimiq:logos-nimiq-horizontal dark:i-nimiq:logos-nimiq-white-horizontal !ml-16 !h-24 !w-90" />
         <span ml-8 text-16 font-light tracking-0.75>Validators</span>
       </NuxtLink>
-      <NuxtLink v-if="validatorDetail" to="/" block w-max nq-arrow-back nq-ghost-btn>
+      <NuxtLink
+        v-if="validatorDetail"
+        :to="{
+          path: '/',
+          query: scoreVersionLinkQuery,
+        }"
+        block w-max nq-arrow-back nq-ghost-btn
+      >
         Go back
       </NuxtLink>
-      <div ml-auto>
-        <div flex="~ items-center gap-8" outline="~ 1.5" :class="statusRequest === 'pending' ? 'outline-neutral/10 text-neutral-800' : isSynced ? 'outline-green-500 text-green-1100' : 'outline-red-500 text-red-1100'" rounded-6 f-text-2xs font-semibold of-clip>
+      <div ml-auto flex="~ items-center gap-12" class="max-sm:order-2 max-sm:ml-0 max-sm:w-full max-sm:justify-between">
+        <ScoreVersionSelect
+          :model-value="selectedScoreVersion"
+          :disabled="statusRequest === 'pending'"
+          @update:model-value="setScoreVersion"
+        />
+        <div flex="~ items-center gap-8" outline="~ 1.5" :class="healthClasses.container" rounded-6 f-text-2xs font-semibold of-clip>
           <CollapsibleRoot w-full>
             <CollapsibleTrigger bg-transparent w-full relative group rounded="6 reka-open:b-0" transition-border-radius of-clip>
               <EnvItem :item="currentEnvItem" component="div" />
@@ -53,18 +147,18 @@ const currentEnvItem = getEnvironmentItem(nimiqNetwork) ?? { network: nimiqNetwo
             </CollapsibleContent>
           </CollapsibleRoot>
 
-          <div flex="~ items-center gap-8" f-px-2xs py-6 whitespace-nowrap :title="`Status for nimiq+${nimiqNetwork}`" :class="statusRequest === 'pending' ? 'bg-neutral-400' : isSynced ? 'bg-green-400' : 'bg-red-400'">
-            <template v-if="statusRequest === 'pending'">
+          <div flex="~ items-center gap-8" f-px-2xs py-6 whitespace-nowrap :title="`Status for nimiq+${nimiqNetwork}`" :class="healthClasses.badge">
+            <template v-if="health.kind === 'synchronizing'">
               <div class="i-nimiq:spinner" />
-              Getting health
+              {{ health.label }}
             </template>
-            <template v-else-if="isSynced">
+            <template v-else-if="health.kind === 'current'">
               <div i-nimiq:duotone-fluctuations f-text-xl />
-              API synced
+              {{ health.label }}
             </template>
             <template v-else>
               <div i-nimiq:alert op-70 f-text-xs />
-              Error
+              {{ health.label }}
             </template>
           </div>
         </div>
@@ -73,19 +167,19 @@ const currentEnvItem = getEnvironmentItem(nimiqNetwork) ?? { network: nimiqNetwo
       <button class="i-nimiq:moon" @click="() => toggleDark()" />
     </header>
     <main flex-1>
-      <div v-if="(!isSynced || error) && $route.path === '/'" bg="red/8" outline="1.5 ~ red-600" rounded-12 f-p-md text="14 red-1100" nq-prose-compact children:max-w-none f-mb-lg>
+      <div v-if="showHealthWarning && $route.path === '/'" bg="red/8" outline="1.5 ~ red-600" rounded-12 f-p-md text="14 red-1100" nq-prose-compact children:max-w-none f-mb-lg>
         <h1 flex="~ items-center gap-12" text-red-1100 f-text-lg>
           <div i-nimiq:alert op-70 text-0.9em m-0 />
-          <template v-if="!isActivitySync">
-            Activity out of sync
-          </template>
-          <template v-else-if="!isScoreSync">
-            Score not computed
-          </template>
+          {{ health.label }}
         </h1>
         <p f-mt-2xs>
-          The database is not fully synchronized with the blockchain. The API may not return the most recent data.
+          API data is not fully current. Stored data remains available where possible.
         </p>
+        <ul v-if="healthDetails.length" f-mt-xs>
+          <li v-for="detail in healthDetails" :key="detail">
+            {{ detail }}
+          </li>
+        </ul>
 
         <pre v-if="error" bg="red/6" text="f-2xs red-1100" outline="red/30" w-inherit>{{ JSON.stringify(error, null, 2) }}</pre>
 
@@ -113,7 +207,7 @@ const currentEnvItem = getEnvironmentItem(nimiqNetwork) ?? { network: nimiqNetwo
         <hr f-my-sm border-red-600>
 
         <p f-mt-md text="f-sm red-1100/80">
-          <strong>Note:</strong> Data synchronization is handled automatically by scheduled tasks that run every 12 hours. A score lag of up to 1 epoch can be expected between sync cycles.
+          <strong>Note:</strong> Data synchronization is handled automatically by scheduled tasks that run every six hours. A score lag of up to 1 epoch can be expected between sync cycles.
         </p>
       </div>
 
diff --git a/app/components/ScorePie.vue b/app/components/ScorePie.vue
index 15350012..b12b9f59 100644
--- a/app/components/ScorePie.vue
+++ b/app/components/ScorePie.vue
@@ -1,5 +1,5 @@
 <script setup lang="ts">
-const { decimals = 1, score = -1 } = defineProps<{ score?: number, decimals?: number }>()
+const { decimals = 1, score } = defineProps<{ score: number | null, decimals?: number }>()
 
 const viewBoxSize = 100
 const center = viewBoxSize / 2
@@ -23,7 +23,7 @@ function generateArcPath(score: number) {
 }
 
 const strokeColor = computed(() => {
-  if (!score || score < 0.6)
+  if (score === null || score < 0.6)
     return 'stroke-red'
   if (score < 0.85)
     return 'stroke-gold'
@@ -50,7 +50,7 @@ const strokeColor = computed(() => {
     </template>
     <template v-else>
       <div font-bold size-full grid="~ place-content-center">
-        NA
+        N/A
       </div>
       <svg
         bg-transparent :viewBox="`0 0 ${viewBoxSize} ${viewBoxSize}`" height="100%" width="100%"
diff --git a/app/components/ScorePies.vue b/app/components/ScorePies.vue
index eba03f8d..2c41b46f 100644
--- a/app/components/ScorePies.vue
+++ b/app/components/ScorePies.vue
@@ -1,26 +1,87 @@
 <script setup lang="ts">
-defineProps<{ dominance: number, reliability: number, availability: number }>()
+import type { ScoreApiValue } from '~~/server/utils/types'
+
+type ScorePiesProps = Pick<
+  ScoreApiValue,
+  | 'availability'
+  | 'dataStatus'
+  | 'dominance'
+  | 'longTermAsOfEpoch'
+  | 'longTermAvailability'
+  | 'longTermCoverage'
+  | 'recentAvailability'
+  | 'recentCoverage'
+  | 'reliability'
+  | 'scoreEpoch'
+  | 'scoreVersion'
+>
+
+const props = defineProps<ScorePiesProps>()
+
+const statusLabel = computed(() => ({
+  current: 'Current',
+  stale: 'Stale',
+  no_score: 'No score',
+})[props.dataStatus])
+
+function formatCoverage(value: number | null) {
+  return value !== null && Number.isFinite(value)
+    ? percentageFormatter.format(value)
+    : 'N/A'
+}
 </script>
 
 <template>
-  <div flex="~ items-center gap-2em">
-    <div>
-      <h4 nq-label text="0.5em center">
-        dominance
-      </h4>
-      <ScorePie text="neutral/70" mx-auto mt-6 size-2.75em :score="dominance" />
-    </div>
-    <div>
-      <h4 nq-label text="0.5em center">
-        availability
-      </h4>
-      <ScorePie text="neutral/70" mx-auto mt-6 size-2.75em :score="availability" />
+  <div flex="~ col items-center gap-12">
+    <div flex="~ items-center gap-2em wrap justify-center">
+      <div>
+        <h4 nq-label text="0.5em center">
+          dominance
+        </h4>
+        <ScorePie text="neutral/70" mx-auto mt-6 size-2.75em :score="dominance" />
+      </div>
+      <div v-if="scoreVersion === 1">
+        <h4 nq-label text="0.5em center">
+          availability
+        </h4>
+        <ScorePie text="neutral/70" mx-auto mt-6 size-2.75em :score="availability" />
+      </div>
+      <template v-else>
+        <div>
+          <h4 nq-label text="0.5em center">
+            recent
+          </h4>
+          <ScorePie text="neutral/70" mx-auto mt-6 size-2.75em :score="recentAvailability" />
+        </div>
+        <div>
+          <h4 nq-label text="0.5em center">
+            long-term
+          </h4>
+          <ScorePie text="neutral/70" mx-auto mt-6 size-2.75em :score="longTermAvailability" />
+        </div>
+        <div>
+          <h4 nq-label text="0.5em center">
+            combined
+          </h4>
+          <ScorePie text="neutral/70" mx-auto mt-6 size-2.75em :score="availability" />
+        </div>
+      </template>
+      <div>
+        <h4 nq-label text="0.5em center">
+          reliability
+        </h4>
+        <ScorePie text="neutral/70" mx-auto mt-6 size-2.75em :score="reliability" />
+      </div>
     </div>
     <div>
-      <h4 nq-label text="0.5em center">
-        reliability
-      </h4>
-      <ScorePie text="neutral/70" mx-auto mt-6 size-2.75em :score="reliability" />
+      <span nq-pill nq-pill-tertiary>v{{ scoreVersion }}</span>
+      <span nq-pill nq-pill-tertiary ml-4>{{ statusLabel }}</span>
+      <template v-if="scoreVersion === 2">
+        <span nq-pill nq-pill-tertiary ml-4>Recent coverage {{ formatCoverage(recentCoverage) }}</span>
+        <span nq-pill nq-pill-tertiary ml-4>Long coverage {{ formatCoverage(longTermCoverage) }}</span>
+        <span nq-pill nq-pill-tertiary ml-4>Score epoch {{ scoreEpoch ?? 'N/A' }}</span>
+        <span nq-pill nq-pill-tertiary ml-4>Long-term as of {{ longTermAsOfEpoch ?? 'N/A' }}</span>
+      </template>
     </div>
   </div>
 </template>
diff --git a/app/components/ScoreVersionSelect.vue b/app/components/ScoreVersionSelect.vue
new file mode 100644
index 00000000..e19f9e85
--- /dev/null
+++ b/app/components/ScoreVersionSelect.vue
@@ -0,0 +1,35 @@
+<script setup lang="ts">
+import type { ScoreVersion } from '~/utils/score-version'
+
+defineProps<{ disabled?: boolean }>()
+
+const model = defineModel<ScoreVersion>({ required: true })
+</script>
+
+<template>
+  <label flex="~ items-center gap-6" text="11 neutral-700" font-semibold>
+    <span nq-label text="9 neutral-700">Score</span>
+    <span relative>
+      <select
+        v-model.number="model"
+        aria-label="Score version"
+        :disabled
+        appearance-none bg-neutral-0 outline="~ 1.5 neutral-300 hocus:blue"
+        rounded-6 py-6 pl-10 pr-26 text="11 neutral-800" font-semibold
+        cursor-pointer disabled:cursor-wait disabled:op-60
+      >
+        <option :value="1">
+          v1
+        </option>
+        <option :value="2">
+          v2
+        </option>
+      </select>
+      <span
+        aria-hidden
+        pointer-events-none absolute right-7 top="50%" translate-y="-50%"
+        i-nimiq:chevron-top-down text="10 neutral-600"
+      />
+    </span>
+  </label>
+</template>
diff --git a/app/components/ValidatorsTable.vue b/app/components/ValidatorsTable.vue
index ca11aef3..0c078bed 100644
--- a/app/components/ValidatorsTable.vue
+++ b/app/components/ValidatorsTable.vue
@@ -1,11 +1,17 @@
 <script setup lang="ts">
 import type { ColumnDef, SortDirection, SortingState } from '@tanstack/vue-table'
 import type { FetchedValidator } from '~~/server/utils/types'
+import type { ScoreVersion } from '~/utils/score-version'
 import { getCoreRowModel, getFilteredRowModel, getSortedRowModel, useVueTable } from '@tanstack/vue-table'
+import { compareScoreValues, mapScoreDisplay } from '~/utils/score-display'
+import { mergeScoreVersionQuery } from '~/utils/score-version'
 
 // @unocss-include
 
-const { validators } = defineProps<{ validators: FetchedValidator[] }>()
+const { validators, scoreVersion } = defineProps<{
+  validators: FetchedValidator[]
+  scoreVersion: ScoreVersion
+}>()
 
 // Helper function to convert Luna to NIM for display
 function formatLunaAsNim(lunaValue: number): string {
@@ -92,7 +98,7 @@ const columns: ColumnDef<FetchedValidator>[] = [
     header: 'Score',
     enableSorting: true,
     enableGlobalFilter: false,
-    sortingFn: (a, b) => (a.original.score?.total || 0) - (b.original.score?.total || 0),
+    sortingFn: (a, b) => compareScoreValues(a.original.score.total, b.original.score.total),
   },
 ]
 
@@ -125,12 +131,17 @@ const table = useVueTable({
 })
 
 const apiUrl = computed(() => {
-  let base = '/api/v1/validators'
-  if (showUnknown.value)
-    base += '?only-known=false'
-  return base
+  const onlyKnownQuery = showUnknown.value ? '&only-known=false' : ''
+  return `/api/v1/validators?score-version=${scoreVersion}${onlyKnownQuery}`
 })
 
+function openValidator(address: string) {
+  return navigateTo({
+    path: `/validator/${address}`,
+    query: mergeScoreVersionQuery({}, scoreVersion),
+  })
+}
+
 // Clear search with proper state management
 async function clearSearch() {
   globalFilter.value = ''
@@ -167,6 +178,10 @@ const filteredRowsCount = computed(() => {
     return 0
   }
 })
+
+function getScoreDisplay(validator: FetchedValidator) {
+  return mapScoreDisplay(validator.score)
+}
 </script>
 
 <template>
@@ -178,13 +193,13 @@ const filteredRowsCount = computed(() => {
     >
       <!-- API and Trust Score links -->
       <div flex="~ items-center gap-32">
-        <NuxtLink
-          :to="apiUrl" class="flex items-center" target="_blank" nq-arrow
+        <a
+          :href="apiUrl" class="flex items-center" target="_blank" nq-arrow
           un-text="f-xs neutral-700 hocus:neutral-800" transition-colors font-semibold
         >
           <div i-nimiq:code mr-8 />
           API
-        </NuxtLink>
+        </a>
 
         <NuxtLink
           to="https://github.com/nimiq/validators-api/tree/main/packages/nimiq-validator-trustscore" external class="flex items-center"
@@ -296,7 +311,7 @@ const filteredRowsCount = computed(() => {
         <tbody>
           <tr
             v-for="row in tableRows" :key="`validator-${row.original.id}-${globalFilter}`" class="table-row"
-            @click="navigateTo(`/validator/${row.original.address}`)"
+            @click="openValidator(row.original.address)"
           >
             <td class="cell-identicon">
               <Identicon
@@ -349,10 +364,16 @@ const filteredRowsCount = computed(() => {
             </td>
 
             <td class="cell-score">
-              <ScorePie
-                size-32 text-12 mx-auto :score="row.original.score.total!" :decimals="0"
-                :style="{ 'view-transition-name': `score-${row.original.id}-${globalFilter}` }"
-              />
+              <div flex="~ col items-center gap-4">
+                <ScorePie
+                  size-32 text-12 :score="getScoreDisplay(row.original).value" :decimals="0"
+                  :style="{ 'view-transition-name': `score-${row.original.id}-${globalFilter}` }"
+                />
+                <div flex="~ gap-4" text="9 neutral-600" whitespace-nowrap>
+                  <span>v{{ getScoreDisplay(row.original).version }}</span>
+                  <span>{{ getScoreDisplay(row.original).statusLabel }}</span>
+                </div>
+              </div>
             </td>
           </tr>
         </tbody>
diff --git a/app/components/validator/LayoutDashboard.vue b/app/components/validator/LayoutDashboard.vue
index 64e34ff2..ee337417 100644
--- a/app/components/validator/LayoutDashboard.vue
+++ b/app/components/validator/LayoutDashboard.vue
@@ -1,10 +1,12 @@
 <script setup lang="ts">
 import type { FetchedValidatorDetails } from '~~/server/utils/validators'
 import { CurveType } from 'vue-chrts'
+import { mapScoreDisplay } from '~/utils/score-display'
 
 const props = defineProps<{ validator: FetchedValidatorDetails }>()
 const validatorRef = computed(() => props.validator)
 const { scoreTrendData, scoreTrendXFormatter, balanceData, balanceXFormatter, balanceYDomain, activityData, activityXFormatter, feeDisplay, payoutDisplay, currentStakers, donutScoreData } = useValidatorCharts(validatorRef)
+const scoreState = computed(() => mapScoreDisplay(props.validator.score))
 
 const scoreCategories = { total: { name: 'Score', color: 'var(--colors-green)' } }
 const balanceCategories = { balance: { name: 'Balance (NIM)', color: 'var(--colors-gold)' } }
@@ -44,10 +46,13 @@ const donutCategories = { 0: { name: 'Availability', color: 'var(--colors-blue)'
         <div>
           <span nq-label text="11 neutral-800">Score</span>
           <p text-24 font-bold text-green lh-none mt-4>
-            {{ Math.round((validator.score?.total ?? 0) * 100) }}
+            {{ scoreState.value === null ? 'N/A' : Math.round(scoreState.value * 100) }}
+          </p>
+          <p text="10 neutral-600" mt-4>
+            {{ scoreState.versionLabel }} · {{ scoreState.statusLabel }}
           </p>
         </div>
-        <ScorePie size-40 text-14 :score="validator.score?.total || 0" />
+        <ScorePie size-40 text-14 :score="scoreState.value" />
       </div>
     </div>
 
@@ -56,11 +61,15 @@ const donutCategories = { 0: { name: 'Availability', color: 'var(--colors-blue)'
       <div bg-neutral-0 outline="~ 1.5 neutral/6" rounded-8 shadow f-p-md>
         <span nq-label text="11 neutral-800" mb-8 block>Sub-Scores</span>
         <DonutChart
+          v-if="donutScoreData.length"
           :data="donutScoreData" :radius="80" :arc-width="16" :pad-angle="0.03"
           :categories="donutCategories" hide-legend
         />
+        <p v-else text="center neutral-600" py-24>
+          N/A
+        </p>
         <div flex="~ justify-center gap-16" mt-12>
-          <ScorePies v-if="validator.score" v-bind="validator.score" text-20 />
+          <ScorePies v-bind="validator.score" text-20 />
         </div>
       </div>
       <div bg-neutral-0 outline="~ 1.5 neutral/6" rounded-8 shadow f-p-md>
diff --git a/app/components/validator/LayoutDeepDive.vue b/app/components/validator/LayoutDeepDive.vue
index d85ad7aa..9c7bc984 100644
--- a/app/components/validator/LayoutDeepDive.vue
+++ b/app/components/validator/LayoutDeepDive.vue
@@ -1,10 +1,12 @@
 <script setup lang="ts">
 import type { FetchedValidatorDetails } from '~~/server/utils/validators'
 import { CurveType } from 'vue-chrts'
+import { mapScoreDisplay } from '~/utils/score-display'
 
 const props = defineProps<{ validator: FetchedValidatorDetails }>()
 const validatorRef = computed(() => props.validator)
 const { scoreTrendAllData, scoreTrendAllXFormatter, stakersData, stakersXFormatter, stakersYDomain, activityStats, feeDisplay, payoutDisplay } = useValidatorCharts(validatorRef)
+const scoreState = computed(() => mapScoreDisplay(props.validator.score))
 
 const allScoreCategories = {
   total: { name: 'Total', color: 'var(--colors-green)' },
@@ -18,12 +20,30 @@ const stakersCategories = { stakers: { name: 'Stakers', color: 'var(--colors-blu
 const dualChartData = computed(() => {
   if (!props.validator?.activity || !props.validator?.scores)
     return []
-  const scoreMap = new Map(props.validator.scores.map(s => [s.epochNumber, s.total]))
-  return props.validator.activity.map(a => ({
-    epoch: a.epochNumber,
-    balance: a.balance / 1e5,
-    score: scoreMap.get(a.epochNumber) ?? 0,
-  }))
+  const activityByEpoch = new Map(props.validator.activity.map(activity => [activity.epochNumber, activity]))
+  const scores = prepareScoreHistory(
+    props.validator.scores,
+    props.validator.score.scoreVersion,
+    ['total'],
+  )
+  return scores.flatMap((score) => {
+    if (
+      typeof score.epochNumber !== 'number'
+      || !Number.isFinite(score.epochNumber)
+      || typeof score.total !== 'number'
+      || !Number.isFinite(score.total)
+    ) {
+      return []
+    }
+    const activity = activityByEpoch.get(score.epochNumber)
+    return activity
+      ? [{
+          epoch: score.epochNumber,
+          balance: activity.balance / 1e5,
+          score: score.total,
+        }]
+      : []
+  })
 })
 const dualChartXFormatter = computed(() => (index: number) => {
   const epoch = dualChartData.value[Math.round(index)]?.epoch
@@ -38,9 +58,12 @@ const dualLineCategories = { score: { name: 'Score', color: 'var(--colors-green)
     <!-- Hero: Score -->
     <div flex="~ col items-center" bg-neutral-0 outline="~ 1.5 neutral/6" rounded-8 shadow f-p-md>
       <span nq-label text="11 neutral-800">Current Score</span>
-      <ScorePie size-128 text-40 :score="validator.score?.total || 0" mt-16 />
-      <span text-14 text-neutral-700 mt-8>Epoch {{ validator.score?.epochNumber }}</span>
-      <ScorePies v-if="validator.score" v-bind="validator.score" text-28 mt-24 />
+      <ScorePie size-128 text-40 :score="scoreState.value" mt-16 />
+      <span text-14 text-neutral-700 mt-8>
+        {{ scoreState.versionLabel }} · {{ scoreState.statusLabel }}
+      </span>
+      <span text-14 text-neutral-700 mt-4>Epoch {{ validator.score.scoreEpoch ?? 'N/A' }}</span>
+      <ScorePies v-bind="validator.score" text-28 mt-24 />
     </div>
 
     <!-- Score trends: 4 overlapping areas -->
diff --git a/app/components/validator/LayoutProfile.vue b/app/components/validator/LayoutProfile.vue
index 13ffa244..ca45d1a5 100644
--- a/app/components/validator/LayoutProfile.vue
+++ b/app/components/validator/LayoutProfile.vue
@@ -1,10 +1,12 @@
 <script setup lang="ts">
 import type { FetchedValidatorDetails } from '~~/server/utils/validators'
 import { CurveType } from 'vue-chrts'
+import { mapScoreDisplay } from '~/utils/score-display'
 
 const props = defineProps<{ validator: FetchedValidatorDetails }>()
 const validatorRef = computed(() => props.validator)
 const { scoreTrendData, scoreTrendXFormatter, balanceData, balanceXFormatter, balanceYDomain, stakersData, stakersXFormatter, stakersYDomain, activityStats, feeDisplay, payoutDisplay, currentBalance, currentStakers } = useValidatorCharts(validatorRef)
+const scoreState = computed(() => mapScoreDisplay(props.validator.score))
 
 const scoreCategories = { total: { name: 'Score', color: 'var(--colors-green)' } }
 const balanceCategories = { balance: { name: 'Balance (NIM)', color: 'var(--colors-gold)' } }
@@ -43,9 +45,12 @@ const stakersCategories = { stakers: { name: 'Stakers', color: 'var(--colors-blu
       <!-- Left 60% -->
       <div flex="~ col gap-16">
         <!-- Score card -->
-        <div bg-neutral-0 outline="~ 1.5 neutral/6" rounded-8 shadow f-p-md flex="~ items-center gap-24">
-          <ScorePie size-96 text-32 :score="validator.score?.total || 0" />
-          <ScorePies v-if="validator.score" v-bind="validator.score" text-24 />
+        <div bg-neutral-0 outline="~ 1.5 neutral/6" rounded-8 shadow f-p-md flex="~ items-center gap-24 wrap">
+          <div flex="~ col items-center gap-8">
+            <ScorePie size-96 text-32 :score="scoreState.value" />
+            <span text="11 neutral-600">{{ scoreState.versionLabel }} · {{ scoreState.statusLabel }}</span>
+          </div>
+          <ScorePies v-bind="validator.score" text-24 />
         </div>
 
         <!-- Score trend -->
diff --git a/app/composables/useScoreVersionQuery.ts b/app/composables/useScoreVersionQuery.ts
new file mode 100644
index 00000000..e1ccbdba
--- /dev/null
+++ b/app/composables/useScoreVersionQuery.ts
@@ -0,0 +1,30 @@
+import type { ScoreVersion } from '~/utils/score-version'
+import {
+  createScoreVersionRequestQuery,
+  mergeScoreVersionQuery,
+  parseScoreVersion,
+} from '~/utils/score-version'
+
+export function useScoreVersionQuery() {
+  const route = useRoute()
+
+  const requestedScoreVersion = computed(() =>
+    parseScoreVersion(route.query['score-version']),
+  )
+  const scoreVersionRequestQuery = computed(() =>
+    createScoreVersionRequestQuery(route.query['score-version']),
+  )
+
+  async function setScoreVersion(scoreVersion: ScoreVersion) {
+    await navigateTo({
+      path: route.path,
+      query: mergeScoreVersionQuery(route.query, scoreVersion),
+    }, { replace: true })
+  }
+
+  return {
+    requestedScoreVersion,
+    scoreVersionRequestQuery,
+    setScoreVersion,
+  }
+}
diff --git a/app/composables/useValidatorCharts.test.ts b/app/composables/useValidatorCharts.test.ts
index 1a2dd4cc..db747cf2 100644
--- a/app/composables/useValidatorCharts.test.ts
+++ b/app/composables/useValidatorCharts.test.ts
@@ -1,5 +1,11 @@
 import { describe, expect, it } from 'vitest'
-import { createEpochFormatter, createPaddedDomain, ensureDrawableLineData } from './useValidatorCharts'
+import {
+  createEpochFormatter,
+  createPaddedDomain,
+  ensureDrawableLineData,
+  prepareActivityHistory,
+  prepareScoreHistory,
+} from './useValidatorCharts'
 
 describe('validator chart helpers', () => {
   it('formats chart x ticks from the data epoch instead of the raw index', () => {
@@ -23,4 +29,74 @@ describe('validator chart helpers', () => {
       { balance: 388_367_850 },
     ], 'balance')).toEqual([386_426_010.75, 390_309_689.25])
   })
+
+  it('filters score history to the selected version and sorts epochs ascending', () => {
+    const scores = [
+      { epochNumber: 14, scoreVersion: 2 as const, total: 0.8 },
+      { epochNumber: 12, scoreVersion: 1 as const, total: 0.7 },
+      { epochNumber: 13, scoreVersion: 2 as const, total: 0.75 },
+    ]
+
+    expect(prepareScoreHistory(scores, 2, ['total']))
+      .toEqual([scores[2], scores[0]])
+  })
+
+  it('preserves true zero scores and excludes null or non-finite totals', () => {
+    const scores = [
+      { epochNumber: 15, scoreVersion: 2 as const, total: null },
+      { epochNumber: 16, scoreVersion: 2 as const, total: 0 },
+      { epochNumber: 17, scoreVersion: 2 as const, total: Number.NaN },
+    ]
+
+    expect(prepareScoreHistory(scores, 2, ['total']))
+      .toEqual([scores[1]])
+  })
+
+  it('excludes rows missing a component required by a multi-series chart', () => {
+    const scores = [
+      {
+        epochNumber: 18,
+        scoreVersion: 2 as const,
+        total: 0.8,
+        availability: null,
+        dominance: 0.9,
+        reliability: 0.95,
+      },
+      {
+        epochNumber: 19,
+        scoreVersion: 2 as const,
+        total: 0,
+        availability: 0,
+        dominance: 0.9,
+        reliability: 0.95,
+      },
+    ]
+
+    expect(prepareScoreHistory(
+      scores,
+      2,
+      ['total', 'availability', 'dominance', 'reliability'],
+    )).toEqual([scores[1]])
+  })
+
+  it('sorts activity history ascending and excludes rows missing chart fields', () => {
+    const activity = [
+      { epochNumber: 1249, balance: 30, stakers: 3, rewarded: 8, missed: 1 },
+      { epochNumber: 1246, balance: 0, stakers: 0, rewarded: 0, missed: 0 },
+      { epochNumber: 1247, balance: 10, stakers: 1, rewarded: 6, missed: 0 },
+      { epochNumber: 1248, balance: 20, stakers: 2, rewarded: 7, missed: 1 },
+      { epochNumber: 1250, balance: Number.NaN, stakers: 4, rewarded: 9, missed: 0 },
+      { epochNumber: 1251, balance: -1, stakers: 5, rewarded: 10, missed: 0 },
+      { epochNumber: 1252, balance: 40, stakers: -1, rewarded: 11, missed: 0 },
+      { epochNumber: 1253, balance: 50, stakers: 6, rewarded: -1, missed: 0 },
+      { epochNumber: 1254, balance: 60, stakers: 7, rewarded: 12, missed: -1 },
+    ]
+
+    expect(prepareActivityHistory(activity, ['balance']).map(row => row.epochNumber))
+      .toEqual([1246, 1247, 1248, 1249, 1252, 1253, 1254])
+    expect(prepareActivityHistory(activity, ['stakers']).map(row => row.epochNumber))
+      .toEqual([1246, 1247, 1248, 1249, 1250, 1251, 1253, 1254])
+    expect(prepareActivityHistory(activity, ['rewarded', 'missed']).map(row => row.epochNumber))
+      .toEqual([1246, 1247, 1248, 1249, 1250, 1251, 1252])
+  })
 })
diff --git a/app/composables/useValidatorCharts.ts b/app/composables/useValidatorCharts.ts
index b9cb63a5..2c731387 100644
--- a/app/composables/useValidatorCharts.ts
+++ b/app/composables/useValidatorCharts.ts
@@ -1,9 +1,10 @@
-import type { Activity, Score } from '~~/server/utils/drizzle'
+import type { Activity } from '~~/server/utils/drizzle'
+import type { ScoreApiValue } from '~~/server/utils/types'
 
 interface ValidatorData {
-  scores: Score[]
+  scores: ScoreApiValue[]
   activity: Activity[]
-  score?: Score
+  score: ScoreApiValue
   fee: number | null
   payoutType: string | null
 }
@@ -12,6 +13,66 @@ interface EpochData {
   epoch: number
 }
 
+interface ScoreHistoryRow {
+  epochNumber: number | null
+  scoreVersion: 1 | 2
+}
+
+interface ActivityHistoryRow {
+  epochNumber: number | null
+}
+
+function isFiniteNumber(value: unknown): value is number {
+  return typeof value === 'number' && Number.isFinite(value)
+}
+
+function isNonNegativeFiniteNumber(value: unknown): value is number {
+  return isFiniteNumber(value) && value >= 0
+}
+
+export function prepareActivityHistory<
+  T extends ActivityHistoryRow,
+  K extends keyof T,
+>(activity: readonly T[], requiredFields: readonly K[]): T[] {
+  return activity
+    .filter(row =>
+      isFiniteNumber(row.epochNumber)
+      && Number.isInteger(row.epochNumber)
+      && requiredFields.every(field => isNonNegativeFiniteNumber(row[field])),
+    )
+    .sort((left, right) => {
+      if (!isFiniteNumber(left.epochNumber) || !isFiniteNumber(right.epochNumber))
+        return 0
+      return left.epochNumber - right.epochNumber
+    })
+}
+
+export function prepareScoreHistory<
+  T extends ScoreHistoryRow,
+  K extends keyof T,
+>(scores: readonly T[], scoreVersion: 1 | 2, requiredFields: readonly K[]): T[] {
+  return scores
+    .filter((score) => {
+      if (
+        score.scoreVersion !== scoreVersion
+        || !isFiniteNumber(score.epochNumber)
+        || !Number.isInteger(score.epochNumber)
+      ) {
+        return false
+      }
+
+      return requiredFields.every((field) => {
+        const value = score[field]
+        return isFiniteNumber(value)
+      })
+    })
+    .sort((left, right) => {
+      if (!isFiniteNumber(left.epochNumber) || !isFiniteNumber(right.epochNumber))
+        return 0
+      return left.epochNumber - right.epochNumber
+    })
+}
+
 export function createEpochFormatter(data: readonly EpochData[]) {
   return (index: number) => {
     const roundedIndex = Math.round(index)
@@ -42,40 +103,71 @@ export function createPaddedDomain<T extends Record<string, number>>(data: reado
 }
 
 export function useValidatorCharts(validator: Ref<ValidatorData | null>) {
+  const selectedScoreVersion = computed(() => validator.value?.score.scoreVersion ?? 1)
+
   const scoreTrendData = computed(() => {
     if (!validator.value?.scores)
       return []
-    return ensureDrawableLineData(validator.value.scores.map(s => ({ epoch: s.epochNumber, total: s.total })))
+    const scores = prepareScoreHistory(
+      validator.value.scores,
+      selectedScoreVersion.value,
+      ['total'],
+    )
+    return ensureDrawableLineData(scores.flatMap(score =>
+      isFiniteNumber(score.epochNumber) && isFiniteNumber(score.total)
+        ? [{ epoch: score.epochNumber, total: score.total }]
+        : [],
+    ))
   })
 
   const scoreTrendAllData = computed(() => {
     if (!validator.value?.scores)
       return []
-    return ensureDrawableLineData(validator.value.scores.map(s => ({
-      epoch: s.epochNumber,
-      total: s.total,
-      availability: s.availability,
-      dominance: s.dominance,
-      reliability: s.reliability,
-    })))
+    const scores = prepareScoreHistory(
+      validator.value.scores,
+      selectedScoreVersion.value,
+      ['total', 'availability', 'dominance', 'reliability'],
+    )
+    return ensureDrawableLineData(scores.flatMap(score =>
+      isFiniteNumber(score.epochNumber)
+      && isFiniteNumber(score.total)
+      && isFiniteNumber(score.availability)
+      && isFiniteNumber(score.dominance)
+      && isFiniteNumber(score.reliability)
+        ? [{
+            epoch: score.epochNumber,
+            total: score.total,
+            availability: score.availability,
+            dominance: score.dominance,
+            reliability: score.reliability,
+          }]
+        : [],
+    ))
   })
 
   const balanceData = computed(() => {
     if (!validator.value?.activity)
       return []
-    return validator.value.activity.map(a => ({ epoch: a.epochNumber, balance: a.balance / 1e5 }))
+    return prepareActivityHistory(validator.value.activity, ['balance'])
+      .map(activity => ({ epoch: activity.epochNumber, balance: activity.balance / 1e5 }))
   })
 
   const stakersData = computed(() => {
     if (!validator.value?.activity)
       return []
-    return validator.value.activity.map(a => ({ epoch: a.epochNumber, stakers: a.stakers }))
+    return prepareActivityHistory(validator.value.activity, ['stakers'])
+      .map(activity => ({ epoch: activity.epochNumber, stakers: activity.stakers }))
   })
 
   const activityData = computed(() => {
     if (!validator.value?.activity)
       return []
-    return validator.value.activity.map(a => ({ epoch: a.epochNumber, rewarded: a.rewarded, missed: a.missed }))
+    return prepareActivityHistory(validator.value.activity, ['rewarded', 'missed'])
+      .map(activity => ({
+        epoch: activity.epochNumber,
+        rewarded: activity.rewarded,
+        missed: activity.missed,
+      }))
   })
 
   const scoreTrendXFormatter = computed(() => createEpochFormatter(scoreTrendData.value))
@@ -114,22 +206,28 @@ export function useValidatorCharts(validator: Ref<ValidatorData | null>) {
   })
 
   const currentBalance = computed(() => {
-    if (!validator.value?.activity?.length)
-      return 0
-    return validator.value.activity.at(-1)!.balance / 1e5
+    return balanceData.value.at(-1)?.balance ?? 0
   })
 
   const currentStakers = computed(() => {
-    if (!validator.value?.activity?.length)
-      return 0
-    return validator.value.activity.at(-1)!.stakers
+    return stakersData.value.at(-1)?.stakers ?? 0
   })
 
   // Donut data for sub-scores
   const donutScoreData = computed(() => {
-    if (!validator.value?.score)
-      return [0, 0, 0]
-    return [validator.value.score.availability, validator.value.score.dominance, validator.value.score.reliability]
+    const score = validator.value?.score
+    if (
+      !score
+      || typeof score.availability !== 'number'
+      || !Number.isFinite(score.availability)
+      || typeof score.dominance !== 'number'
+      || !Number.isFinite(score.dominance)
+      || typeof score.reliability !== 'number'
+      || !Number.isFinite(score.reliability)
+    ) {
+      return []
+    }
+    return [score.availability, score.dominance, score.reliability]
   })
 
   return {
diff --git a/app/pages/index.vue b/app/pages/index.vue
index 79df0deb..dd31eede 100644
--- a/app/pages/index.vue
+++ b/app/pages/index.vue
@@ -1,6 +1,8 @@
 <script setup lang="ts">
 import { calculateStakingRewards } from '@nimiq/utils/rewards-calculator'
 import { formatTimeAgo } from '@vueuse/core'
+import { calculateAverageScore } from '~/utils/score-display'
+import { resolveDashboardScoreVersion } from '~/utils/score-version'
 
 // Helper function to convert Luna to NIM for display
 function formatLunaAsNim(lunaValue: number): string {
@@ -11,12 +13,31 @@ function formatLunaAsNim(lunaValue: number): string {
   }).format(lunaValue / 1e5)
 }
 
-const { data: status, status: statusFetch, error: statusError } = await useFetch('/api/v1/status')
+const route = useRoute()
+const { scoreVersionRequestQuery } = useScoreVersionQuery()
+const validatorsQuery = computed(() => ({
+  'only-known': false,
+  ...scoreVersionRequestQuery.value,
+}))
+const { data: status, status: statusFetch, error: statusError } = await useFetch('/api/v1/status', {
+  query: scoreVersionRequestQuery,
+})
 const { data: validators, status: validatorsStatus, error: validatorsError } = await useFetch('/api/v1/validators', {
-  query: { 'only-known': false },
+  query: validatorsQuery,
 })
 const { data: supply } = await useFetch('/api/v1/supply')
+const selectedScoreVersion = computed(() =>
+  resolveDashboardScoreVersion(
+    route.query['score-version'],
+    status.value?.selectedScoreVersion,
+  ),
+)
 const { averageAPY, averageScore, averageStakeSize, totalPools, totalRegistered, totalStakers, averageFee, windowSizeMonths, totalValidators, totalElected } = useStats()
+const averageScoreDisplay = computed(() =>
+  averageScore.value === null
+    ? 'N/A'
+    : decimalsFormatter.format(averageScore.value * 100),
+)
 
 const [DefineStat, Stat] = createReusableTemplate<{ value?: number | string, label: string, color?: string, paddingXs?: boolean, tooltip: MaybeRef<string> }>()
 
@@ -40,11 +61,9 @@ function useStats() {
   const network = useSafeRuntimeConfig().public.nimiqNetwork as 'test-albatross' | 'main-albatross'
 
   const averageScore = computed(() => {
-    if (!validators?.value?.length)
-      return 0
-    const scores = validators.value.map(validator => validator.score?.total).filter(t => !!t) as number[]
-    const totalScore = scores?.reduce((acc, score) => acc + score, 0) || 0
-    return totalScore / scores.length
+    return calculateAverageScore(
+      validators.value?.map(validator => validator.score.total) ?? [],
+    )
   })
 
   const totalStakers = computed(() => validators.value?.reduce((acc, validator) => acc + validator.stakers, 0) || 0)
@@ -141,7 +160,7 @@ function useStats() {
           </span>
         </Stat>
 
-        <Stat :value="decimalsFormatter.format(averageScore * 100)" label="Avg. Score" color="purple" :padding-xs="true" :tooltip="tooltips.averageScore.value" grid-col="1/6 md:1/4 sm:span-1" grid-row="2" />
+        <Stat :value="averageScoreDisplay" label="Avg. Score" color="purple" :padding-xs="true" :tooltip="tooltips.averageScore.value" grid-col="1/6 md:1/4 sm:span-1" grid-row="2" />
         <Stat :value="totalPools" label="Pools" color="red" :padding-xs="true" :tooltip="tooltips.pools.value" grid-col="6/11 md:4/7 sm:span-1" grid-row="2" />
         <Stat :value="percentageFormatter.format(averageFee)" label="Avg. Fee" color="orange" :padding-xs="true" :tooltip="tooltips.averageFee" grid-col="11/16 md:7/10 sm:span-1" grid-row="2" />
         <Stat :value="totalRegistered" label="Tracked" color="blue" :padding-xs="true" :tooltip="tooltips.tracked" grid-col="16/20 md:10/13 sm:span-1" grid-row="2" />
@@ -187,7 +206,7 @@ function useStats() {
         </Stat>
       </div>
 
-      <ValidatorsTable :validators mt-96 />
+      <ValidatorsTable :validators :score-version="selectedScoreVersion" mt-96 />
     </div>
   </div>
 </template>
diff --git a/app/pages/validator/[address].vue b/app/pages/validator/[address].vue
index 6021d68b..5238df97 100644
--- a/app/pages/validator/[address].vue
+++ b/app/pages/validator/[address].vue
@@ -6,8 +6,11 @@ type LayoutKey = 'dashboard' | 'deep-dive' | 'profile'
 type ValidatorDetail = FetchedValidatorDetails & { range?: unknown }
 
 const route = useRoute()
+const { scoreVersionRequestQuery } = useScoreVersionQuery()
 const address = computed(() => Array.isArray(route.params.address) ? route.params.address.join('/') : String(route.params.address || ''))
-const { data: validator } = await useFetch<ValidatorDetail>(() => `/api/v1/validators/${encodeURIComponent(address.value)}`)
+const { data: validator } = await useFetch<ValidatorDetail>(() => `/api/v1/validators/${encodeURIComponent(address.value)}`, {
+  query: scoreVersionRequestQuery,
+})
 const layout = shallowRef<LayoutKey>('dashboard')
 const layouts = [
   { key: 'dashboard' as const, label: 'Dashboard' },
diff --git a/app/utils/score-display.test.ts b/app/utils/score-display.test.ts
new file mode 100644
index 00000000..8d975c35
--- /dev/null
+++ b/app/utils/score-display.test.ts
@@ -0,0 +1,65 @@
+import { describe, expect, it } from 'vitest'
+import {
+  calculateAverageScore,
+  compareScoreValues,
+  mapScoreDisplay,
+} from './score-display'
+
+describe('score display', () => {
+  it('keeps a current zero score distinct from no score', () => {
+    expect(mapScoreDisplay({
+      total: 0,
+      dataStatus: 'current',
+      scoreVersion: 2,
+    })).toEqual({
+      value: 0,
+      status: 'current',
+      statusLabel: 'Current',
+      version: 2,
+      versionLabel: 'v2',
+    })
+  })
+
+  it('maps a missing score to an explicit no-score state', () => {
+    expect(mapScoreDisplay({
+      total: null,
+      dataStatus: 'no_score',
+      scoreVersion: 1,
+    })).toEqual({
+      value: null,
+      status: 'no_score',
+      statusLabel: 'No score',
+      version: 1,
+      versionLabel: 'v1',
+    })
+  })
+
+  it('keeps a stale numeric score and labels it stale', () => {
+    expect(mapScoreDisplay({
+      total: 0.81,
+      dataStatus: 'stale',
+      scoreVersion: 2,
+    })).toEqual({
+      value: 0.81,
+      status: 'stale',
+      statusLabel: 'Stale',
+      version: 2,
+      versionLabel: 'v2',
+    })
+  })
+
+  it('sorts no score below a true zero score', () => {
+    expect([0.67, null, 0].sort(compareScoreValues)).toEqual([null, 0, 0.67])
+  })
+
+  describe('validators index average', () => {
+    it('returns null for N/A when every validator score is missing', () => {
+      expect(calculateAverageScore([null, null])).toBeNull()
+    })
+
+    it('keeps a true zero score in the average', () => {
+      expect(calculateAverageScore([null, 0])).toBe(0)
+      expect(calculateAverageScore([null, 0, 0.6])).toBeCloseTo(0.3)
+    })
+  })
+})
diff --git a/app/utils/score-display.ts b/app/utils/score-display.ts
new file mode 100644
index 00000000..c5e2c6c9
--- /dev/null
+++ b/app/utils/score-display.ts
@@ -0,0 +1,48 @@
+export type ScoreDataStatus = 'current' | 'stale' | 'no_score'
+
+export interface ScoreDisplayInput {
+  total: number | null
+  dataStatus: ScoreDataStatus
+  scoreVersion: 1 | 2
+}
+
+export interface ScoreDisplay {
+  value: number | null
+  status: ScoreDataStatus
+  statusLabel: string
+  version: 1 | 2
+  versionLabel: string
+}
+
+export function mapScoreDisplay(score: ScoreDisplayInput): ScoreDisplay {
+  const statusLabels: Record<ScoreDataStatus, string> = {
+    current: 'Current',
+    stale: 'Stale',
+    no_score: 'No score',
+  }
+
+  return {
+    value: score.total,
+    status: score.dataStatus,
+    statusLabel: statusLabels[score.dataStatus],
+    version: score.scoreVersion,
+    versionLabel: `v${score.scoreVersion}`,
+  }
+}
+
+export function compareScoreValues(left: number | null, right: number | null): number {
+  if (left === null)
+    return right === null ? 0 : -1
+  if (right === null)
+    return 1
+  return left - right
+}
+
+export function calculateAverageScore(scores: readonly (number | null)[]): number | null {
+  const finiteScores = scores.filter(
+    (score): score is number => typeof score === 'number' && Number.isFinite(score),
+  )
+  if (finiteScores.length === 0)
+    return null
+  return finiteScores.reduce((total, score) => total + score, 0) / finiteScores.length
+}
diff --git a/app/utils/score-version.test.ts b/app/utils/score-version.test.ts
new file mode 100644
index 00000000..4fdf74f7
--- /dev/null
+++ b/app/utils/score-version.test.ts
@@ -0,0 +1,41 @@
+import { describe, expect, it } from 'vitest'
+import {
+  createScoreVersionRequestQuery,
+  mergeScoreVersionQuery,
+  parseScoreVersion,
+  resolveDashboardScoreVersion,
+} from './score-version'
+
+describe('score version route query', () => {
+  it('accepts only one exact v1 or v2 query value', () => {
+    expect(parseScoreVersion('1')).toBe(1)
+    expect(parseScoreVersion('2')).toBe(2)
+    expect(parseScoreVersion('3')).toBeUndefined()
+    expect(parseScoreVersion(['2'])).toBeUndefined()
+    expect(parseScoreVersion(undefined)).toBeUndefined()
+  })
+
+  it('falls back to the API-selected version for missing or invalid queries', () => {
+    expect(resolveDashboardScoreVersion(undefined, 2)).toBe(2)
+    expect(resolveDashboardScoreVersion('invalid', 1)).toBe(1)
+    expect(resolveDashboardScoreVersion('2', 1)).toBe(2)
+  })
+
+  it('omits invalid values from API requests', () => {
+    expect(createScoreVersionRequestQuery('1')).toEqual({ 'score-version': 1 })
+    expect(createScoreVersionRequestQuery('2')).toEqual({ 'score-version': 2 })
+    expect(createScoreVersionRequestQuery('invalid')).toEqual({})
+  })
+
+  it('preserves unrelated route query values when changing version', () => {
+    expect(mergeScoreVersionQuery({
+      'search': 'nimiq',
+      'page': '2',
+      'score-version': '1',
+    }, 2)).toEqual({
+      'search': 'nimiq',
+      'page': '2',
+      'score-version': '2',
+    })
+  })
+})
diff --git a/app/utils/score-version.ts b/app/utils/score-version.ts
new file mode 100644
index 00000000..12c9cadb
--- /dev/null
+++ b/app/utils/score-version.ts
@@ -0,0 +1,32 @@
+export type ScoreVersion = 1 | 2
+
+export function parseScoreVersion(value: unknown): ScoreVersion | undefined {
+  if (value === '1')
+    return 1
+  if (value === '2')
+    return 2
+}
+
+export function resolveDashboardScoreVersion(
+  value: unknown,
+  apiDefault: ScoreVersion = 1,
+): ScoreVersion {
+  return parseScoreVersion(value) ?? apiDefault
+}
+
+export function createScoreVersionRequestQuery(value: unknown) {
+  const scoreVersion = parseScoreVersion(value)
+  return scoreVersion === undefined
+    ? {}
+    : { 'score-version': scoreVersion }
+}
+
+export function mergeScoreVersionQuery<T extends Record<string, unknown>>(
+  query: T,
+  scoreVersion: ScoreVersion,
+) {
+  return {
+    ...query,
+    'score-version': String(scoreVersion),
+  }
+}
diff --git a/docs/superpowers/specs/2026-07-28-validator-activity-integrity-hybrid-score-design.md b/docs/superpowers/specs/2026-07-28-validator-activity-integrity-hybrid-score-design.md
new file mode 100644
index 00000000..248f60b4
--- /dev/null
+++ b/docs/superpowers/specs/2026-07-28-validator-activity-integrity-hybrid-score-design.md
@@ -0,0 +1,280 @@
+# Validator Activity Integrity and Hybrid Score Design
+
+## Context
+
+Validator `NQ29 FBVT B4GM S27H UBP4 1MTC GNKQ VPBT 099M` was reportedly offline for two days, but its displayed score barely changed. Production API data exposed two separate problems:
+
+1. Completed validator activity was incomplete while the status endpoint reported the epochs as synchronized.
+2. The score formula softened recent downtime enough that the UI rounded away the change.
+
+The validator activity response lacked epochs `1110` and `1238–1245`, while the global status endpoint only reported epoch `1248` as missing. This proves the existing epoch-completeness heuristic can accept partially stored epochs.
+
+## Goals
+
+- Never infer that a completed epoch is synchronized from a partial set of activity rows.
+- Never treat missing or unfinalized activity as online.
+- Represent synchronization state explicitly as pending, syncing, finalized, or failed.
+- Prevent one failed historical epoch from blocking current activity and scores.
+- Make two continuous offline days lower a normally healthy validator score into roughly the `90–94` range.
+- Preserve long-term validator reputation while making recent outages visible.
+- Make all repair and retry operations idempotent.
+
+## Non-goals
+
+- Penalizing validators for random non-election.
+- Treating RPC or database failures as validator downtime.
+- Replacing all existing score components.
+- Requiring current-epoch placeholders to participate in scoring.
+
+## Root causes
+
+### False epoch completeness
+
+`isCompleteFinalizedEpochActivity()` currently considers an epoch complete when at least one finalized row exists and no elected placeholder exists. Missing rows are invisible, so a partially stored epoch can pass this check.
+
+### Non-atomic activity writes
+
+Activity rows are written concurrently. Each existing row is deleted before its replacement is inserted. A Worker interruption or failed insert can leave rows missing. The epoch can then be incorrectly classified as complete.
+
+### Silent validator persistence failure
+
+Validator persistence can log an error and return without throwing. The activity write then skips that validator without failing the epoch.
+
+### Blocking task order
+
+Epoch synchronization processes the oldest gap first and returns on its first failure. The cron wrapper then skips the snapshot and score task. One historical RPC failure can therefore prevent newer activity and scores from advancing.
+
+### Weak recent-outage response
+
+The current availability calculation uses a 270-day window and a quadratic smoothing curve. Full offline epochs contain `0 rewarded / 0 missed`, so reliability ignores them. Recent epochs also receive less weight than older epochs because activity is ordered oldest-first while weight decreases by index.
+
+## Activity epoch state model
+
+Add an `activity_epochs` table with one row per completed epoch:
+
+| Column                   | Type                | Purpose                                                 |
+| ------------------------ | ------------------- | ------------------------------------------------------- |
+| `epoch_number`           | integer primary key | Completed epoch identifier                              |
+| `status`                 | text                | `syncing`, `finalized`, or `failed`                     |
+| `expected_elected_count` | integer             | Number of elected validator addresses in election block |
+| `stored_elected_count`   | integer             | Number written during successful finalization           |
+| `elected_set_hash`       | text                | Deterministic hash of sorted elected addresses          |
+| `attempt_count`          | integer             | Synchronization attempt count                           |
+| `started_at`             | text                | Latest attempt start time                               |
+| `finalized_at`           | text nullable       | Successful completion time                              |
+| `last_error`             | text nullable       | Latest failure reason                                   |
+
+Current unfinished epochs remain pending by absence from this table. They are never included in score ranges.
+
+### Invariants
+
+An epoch is finalized only when all these conditions hold:
+
+1. Election block was fetched successfully.
+2. Every activity batch was fetched successfully.
+3. Every elected validator address was resolved to a stored validator ID.
+4. Stored elected address set exactly matches election-block address set.
+5. All activity rows and the finalization marker committed atomically.
+
+A validator row absent from a finalized epoch means known random non-election. A validator row absent from an unfinalized epoch means unavailable data and must not be interpreted as online or offline.
+
+## Atomic persistence
+
+For one completed epoch:
+
+1. Fetch and validate the complete epoch in memory.
+2. Resolve all validator IDs with failures configured to throw.
+3. Build deterministic upsert statements for elected activity rows.
+4. Execute one D1 `batch()` containing:
+   - epoch marker upsert to `syncing`;
+   - all activity upserts;
+   - cleanup of stale rows not in the elected set;
+   - epoch marker update to `finalized` as the last statement.
+5. If any statement fails, D1 rolls back the entire batch.
+6. Record a failed attempt separately with its error after rollback.
+
+Use conflict upserts instead of delete-then-insert replacement.
+
+## Existing-data verification
+
+Do not trust the current completeness heuristic and do not blindly fetch every activity batch.
+
+For each epoch in the active 270-day window:
+
+1. Fetch its election block.
+2. Build the sorted elected-validator address set and hash.
+3. Query finalized elected rows currently stored for that epoch.
+4. Compare exact address sets.
+5. Mark matching epochs finalized without refetching all batches.
+6. Fully refetch and atomically replace mismatched epochs.
+
+Repair order:
+
+1. Last 14 completed days, newest first.
+2. Remaining recent failures.
+3. Older 270-day history, newest first.
+
+## Synchronization flow
+
+Normal scheduled synchronization runs every six hours:
+
+1. Determine latest completed epoch.
+2. Synchronize latest unfinalized completed epoch first.
+3. Retry failed epochs inside the 14-day recent window.
+4. Process a bounded historical repair batch.
+5. Run snapshot synchronization independently of historical failures.
+6. Calculate scores only when recent coverage is complete.
+
+A failed epoch records its own error and does not terminate processing of other epochs. A stale `syncing` state is reset and retried on the next run.
+
+## Hybrid score version 2
+
+### Recent availability
+
+Window: last 14 completed days, approximately 29 epochs.
+
+| Epoch status                    | Recent availability treatment  |
+| ------------------------------- | ------------------------------ |
+| `elected_online`                | `1`                            |
+| `elected_degraded`              | `1`; misses affect reliability |
+| `elected_failed_or_offline`     | `0`                            |
+| `not_elected_randomness`        | Excluded                       |
+| `inactive_by_choice_or_removed` | `0`                            |
+| Unfinalized epoch               | Score remains stale            |
+
+Formula:
+
+```text
+recentAvailability = successfulElectedEpochs / electedOrInactiveEpochs
+```
+
+If no eligible epochs exist, no current score is published.
+
+### Long-term availability
+
+Window remains 270 days.
+
+- Random non-election is excluded.
+- Elected offline and voluntary inactivity are penalized.
+- Missing data is never treated as active.
+- Recent epochs receive greater weight than older epochs.
+- Existing smoothing remains to preserve long-term reputation behavior.
+
+Until full historical verification finishes, retain the last complete long-term component and expose its coverage and as-of epoch. Never substitute unknown activity.
+
+### Combined score
+
+```text
+availability =
+  0.5 * longTermAvailability
+  + 0.5 * recentAvailability
+
+total = dominance * reliability * availability
+```
+
+For a normally healthy validator, two continuous offline days should produce approximately:
+
+```text
+longTermAvailability ~= 99.9%
+recentAvailability ~= 86%
+combined availability ~= 93%
+total score ~= 92-93
+```
+
+### Versioning
+
+Score rows gain:
+
+- `score_version`
+- `recent_availability`
+- `long_term_availability`
+- `data_status`
+- `long_term_coverage`
+
+Version 1 history remains identifiable. Version 2 becomes active only after recent-window verification and shadow-score validation succeed.
+
+## API changes
+
+Validator score response includes:
+
+```json
+{
+  "scoreVersion": 2,
+  "recentAvailability": 0.86,
+  "longTermAvailability": 0.999,
+  "availability": 0.9295,
+  "scoreEpoch": 1248,
+  "dataStatus": "complete",
+  "longTermCoverage": 1
+}
+```
+
+Status response includes:
+
+```json
+{
+  "latestCompletedEpoch": 1248,
+  "latestFinalizedEpoch": 1248,
+  "failedEpochs": [],
+  "syncingEpochs": [],
+  "recentCoverage": 1,
+  "longTermCoverage": 1,
+  "scoreStatus": "current"
+}
+```
+
+Do not expose generic `unknown` when a more precise synchronization state exists.
+
+## Rollout
+
+1. Add schema and atomic epoch persistence behind existing score behavior.
+2. Deploy activity verification while score version 1 remains active.
+3. Verify election sets for existing epochs.
+4. Repair mismatches newest-first.
+5. Reach 100% recent-window coverage.
+6. Compute version 2 scores in shadow mode.
+7. Validate expected score movement using production-shaped fixtures.
+8. Switch API and UI to score version 2.
+9. Finish full 270-day verification and rebuild versioned score history.
+
+Production verification and repair require a Wrangler login authorized for Cloudflare account `cf9baad7d68d7ee717f3339731e81dfb`. Current credentials return Cloudflare error `7403`.
+
+## Tests
+
+### Activity integrity
+
+- Partial activity rows cannot finalize an epoch.
+- Wrong elected-validator set cannot finalize an epoch.
+- Failed D1 batch rolls back rows and marker.
+- Validator persistence failure aborts finalization.
+- Activity upserts are idempotent.
+- Stale syncing attempts are retried.
+
+### Scheduling
+
+- Old failed epoch does not block latest completed epoch.
+- Historical failure does not skip snapshot synchronization.
+- Newest completed epoch receives priority.
+- Per-epoch errors remain observable through status data.
+
+### Scoring
+
+- Missing recent epoch keeps score stale.
+- Missing activity is never interpreted as active.
+- Random non-election remains neutral.
+- Offline elected epoch reduces recent availability.
+- Degraded activity affects reliability without double availability penalty.
+- Recent weighting order favors newer epochs.
+- Two continuous offline days lower a healthy score into the `90–94` range.
+- Score version 1 and version 2 rows remain distinguishable.
+
+### Regression fixture
+
+Create a fixture matching the reported validator history:
+
+- historical partial epochs;
+- one random non-election epoch;
+- one finalized offline epoch;
+- one pending placeholder epoch.
+
+Before repair, score must remain stale. After repair and two offline days, score must fall into the expected version 2 range.
diff --git a/nuxt.config.test.ts b/nuxt.config.test.ts
new file mode 100644
index 00000000..0bdff4f3
--- /dev/null
+++ b/nuxt.config.test.ts
@@ -0,0 +1,28 @@
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import wranglerConfig from './wrangler.json'
+
+afterEach(() => {
+  vi.unstubAllEnvs()
+  vi.unstubAllGlobals()
+  vi.resetModules()
+})
+
+describe('score v2 runtime configuration', () => {
+  it('uses the Nitro-compatible NUXT_SCORE_V2_MODE environment variable', async () => {
+    vi.stubEnv('NUXT_SCORE_V2_MODE', 'shadow')
+    vi.stubGlobal('defineNuxtConfig', (config: unknown) => config)
+
+    const { default: config } = await import('./nuxt.config')
+
+    expect(config.runtimeConfig?.scoreV2Mode).toBe('shadow')
+  })
+
+  it('publishes the Nitro-compatible variable in both Wrangler environments', () => {
+    expect(wranglerConfig.vars).toEqual(expect.objectContaining({
+      NUXT_SCORE_V2_MODE: 'off',
+    }))
+    expect(wranglerConfig.env.testnet.vars).toEqual(expect.objectContaining({
+      NUXT_SCORE_V2_MODE: 'off',
+    }))
+  })
+})
diff --git a/nuxt.config.ts b/nuxt.config.ts
index 7f99f741..bc44d2d2 100644
--- a/nuxt.config.ts
+++ b/nuxt.config.ts
@@ -7,19 +7,32 @@ import wasm from 'vite-plugin-wasm'
 import { z } from 'zod'
 import { description, name, version } from './package.json'
 
+const remoteMigrationRequested = process.env.NUXT_HUB_REMOTE_MIGRATION === '1'
+const hasRemoteMigrationCredentials = Boolean(
+  process.env.NUXT_HUB_CLOUDFLARE_ACCOUNT_ID
+  && process.env.NUXT_HUB_CLOUDFLARE_DATABASE_ID
+  && process.env.NUXT_HUB_CLOUDFLARE_API_TOKEN,
+)
+
+if (remoteMigrationRequested && !hasRemoteMigrationCredentials)
+  throw new Error('Remote migration requires all NUXT_HUB_CLOUDFLARE_* credentials')
+
 // https://nuxt.com/docs/api/configuration/nuxt-config
 export default defineNuxtConfig({
   devtools: { enabled: true },
   modules: ['@vueuse/nuxt', '@unocss/nuxt', '@nuxtjs/color-mode', '@nuxt/eslint', '@nuxthub/core', '@nuxt/image', '@nuxt/fonts', 'reka-ui/nuxt', 'nuxt-safe-runtime-config', 'nuxt-charts'],
 
   hub: {
-    db: 'sqlite',
+    db: remoteMigrationRequested && hasRemoteMigrationCredentials
+      ? { dialect: 'sqlite', driver: 'd1-http' }
+      : 'sqlite',
     blob: true,
     cache: true,
   },
 
   runtimeConfig: {
     albatrossRpcNodeUrl: process.env.ALBATROSS_RPC_NODE_URL || '',
+    scoreV2Mode: process.env.NUXT_SCORE_V2_MODE || 'off',
     slackWebhookUrl: process.env.NUXT_SLACK_WEBHOOK_URL || '',
     public: {
       gitBranch: execSync('git branch --show-current', { stdio: ['ignore', 'pipe', 'ignore'] }).toString().trim(),
@@ -30,6 +43,7 @@ export default defineNuxtConfig({
   safeRuntimeConfig: {
     $schema: z.object({
       albatrossRpcNodeUrl: z.string().describe('Albatross RPC Node URL is required'),
+      scoreV2Mode: z.enum(['off', 'shadow', 'active']).default('off').describe('Score v2 rollout mode'),
       slackWebhookUrl: z.string().describe('Slack webhook URL must be a valid string'),
       public: z.object({
         gitBranch: z.string().describe('Git branch is required'),
@@ -148,8 +162,8 @@ export default defineNuxtConfig({
       tasks: true,
     },
     scheduledTasks: {
-      // 12-hour sync: wrapper task records run + executes sync tasks
-      '0 */12 * * *': ['cron:sync'],
+      // Six-hour sync: wrapper task records run + executes sync tasks
+      '0 */6 * * *': ['cron:sync'],
     },
     openAPI: {
       meta: { title: name, description, version },
diff --git a/package.json b/package.json
index 61cc17f6..600165c3 100644
--- a/package.json
+++ b/package.json
@@ -17,7 +17,7 @@
     "generate": "nuxt generate",
     "worker:dev": "npx wrangler --cwd .output dev",
     "worker:dev:mainnet:prod": "tsx scripts/dev-mainnet-prod-worker.ts",
-    "worker:trigger-sync": "curl 'http://localhost:8787/__scheduled?cron=0+*/12+*+*+*'",
+    "worker:trigger-sync": "curl 'http://localhost:8787/__scheduled?cron=0+*/6+*+*+*'",
     "postinstall": "nuxt prepare",
     "prepublishOnly": "nr build",
     "typecheck": "nuxt typecheck && nr -r typecheck",
@@ -27,10 +27,8 @@
     "test": "vitest",
     "db:generate": "drizzle-kit generate",
     "db:delete": "drizzle-kit drop",
-    "db:apply:cron-runs:mainnet": "wrangler d1 execute validators-api-mainnet --remote --yes --command \"CREATE TABLE IF NOT EXISTS cron_runs (id integer PRIMARY KEY AUTOINCREMENT NOT NULL, cron text NOT NULL, network text NOT NULL, git_branch text, started_at text NOT NULL, finished_at text, status text NOT NULL, error_message text, meta text);\" && wrangler d1 execute validators-api-mainnet --remote --yes --command \"CREATE INDEX IF NOT EXISTS idx_cron_runs_started_at ON cron_runs (started_at);\"",
-    "db:apply:cron-runs:testnet": "wrangler d1 execute validators-api-testnet --remote --yes --command \"CREATE TABLE IF NOT EXISTS cron_runs (id integer PRIMARY KEY AUTOINCREMENT NOT NULL, cron text NOT NULL, network text NOT NULL, git_branch text, started_at text NOT NULL, finished_at text, status text NOT NULL, error_message text, meta text);\" && wrangler d1 execute validators-api-testnet --remote --yes --command \"CREATE INDEX IF NOT EXISTS idx_cron_runs_started_at ON cron_runs (started_at);\"",
-    "db:apply:is-listed:mainnet": "wrangler d1 execute validators-api-mainnet --remote --yes --command \"ALTER TABLE validators ADD COLUMN is_listed integer;\"",
-    "db:apply:is-listed:testnet": "wrangler d1 execute validators-api-testnet --remote --yes --command \"ALTER TABLE validators ADD COLUMN is_listed integer;\"",
+    "db:migrate:mainnet": "NUXT_HUB_REMOTE_MIGRATION=1 nuxt-db migrate --dotenv .env.mainnet",
+    "db:migrate:testnet": "NUXT_HUB_REMOTE_MIGRATION=1 nuxt-db migrate --dotenv .env.testnet",
     "release": "bumpp -r && nr -r publish",
     "validate:json-files": "tsx scripts/validate-json-files.ts",
     "validators:bundle:generate": "tsx scripts/generate-validators-bundle.ts"
diff --git a/packages/nimiq-validator-trustscore/build.config.ts b/packages/nimiq-validator-trustscore/build.config.ts
index e6b67a4f..043eea95 100644
--- a/packages/nimiq-validator-trustscore/build.config.ts
+++ b/packages/nimiq-validator-trustscore/build.config.ts
@@ -4,6 +4,7 @@ export default defineBuildConfig({
   entries: [
     'src/fetcher',
     'src/score',
+    'src/score-v2',
     'src/types',
     'src/range',
     'src/epoch-status',
diff --git a/packages/nimiq-validator-trustscore/package.json b/packages/nimiq-validator-trustscore/package.json
index 48d9a33c..e14560ad 100644
--- a/packages/nimiq-validator-trustscore/package.json
+++ b/packages/nimiq-validator-trustscore/package.json
@@ -22,6 +22,10 @@
       "types": "./dist/score.d.mts",
       "import": "./dist/score.mjs"
     },
+    "./score-v2": {
+      "types": "./dist/score-v2.d.mts",
+      "import": "./dist/score-v2.mjs"
+    },
     "./types": {
       "types": "./dist/types.d.mts",
       "import": "./dist/types.mjs"
diff --git a/packages/nimiq-validator-trustscore/src/fetcher.test.ts b/packages/nimiq-validator-trustscore/src/fetcher.test.ts
new file mode 100644
index 00000000..d6dafcf8
--- /dev/null
+++ b/packages/nimiq-validator-trustscore/src/fetcher.test.ts
@@ -0,0 +1,177 @@
+import type { FetchEpochsOptions } from './fetcher'
+import type { ElectionSet } from './types'
+import { InherentType } from 'nimiq-rpc-client-ts/types'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { electionBlockToElectionSet, fetchActivity, fetchElectionSet, fetchEpochs } from './fetcher'
+
+const rpcMocks = vi.hoisted(() => ({
+  getBlockByNumber: vi.fn(),
+  getEpochNumber: vi.fn(),
+  getInherentsByBatchNumber: vi.fn(),
+  getStakersByValidatorAddress: vi.fn(),
+  getValidatorByAddress: vi.fn(),
+  getValidators: vi.fn(),
+}))
+
+vi.mock('@nimiq/utils/albatross-policy', () => ({
+  batchAt: (blockNumber: number) => blockNumber,
+  BATCHES_PER_EPOCH: 1,
+  electionBlockOf: (epochIndex: number) => epochIndex * 1000,
+  firstBlockOf: (epochIndex: number) => (epochIndex - 1) * 1000 + 1,
+  isElectionBlockAt: () => true,
+  SLOTS: 512,
+}))
+
+vi.mock('nimiq-rpc-client-ts/http', () => rpcMocks)
+
+const ADDRESS_A = 'NQ02 31N6 3KM5 T6G5 22TN EPF5 5XPY RLHK RMB3'
+const ADDRESS_A_COMPACT = 'nq0231n63km5t6g522tnepf55xpyrlhkrmb3'
+const ADDRESS_B = 'NQ29 FBVT B4GM S27H UBP4 1MTC GNKQ VPBT 099M'
+
+function createElectionSet(epochIndex: number, validators: ElectionSet['validators'] = [{ address: ADDRESS_A, numSlots: 3 }]): ElectionSet {
+  return {
+    epochIndex,
+    electionBlockNumber: (epochIndex - 1) * 1000,
+    validators,
+  }
+}
+
+beforeEach(() => {
+  vi.clearAllMocks()
+  rpcMocks.getBlockByNumber.mockImplementation(async () => [
+    true,
+    undefined,
+    {
+      isElectionBlock: true,
+      slots: [{ validator: ADDRESS_A, numSlots: 3 }],
+    },
+  ])
+  rpcMocks.getEpochNumber.mockResolvedValue([true, undefined, 100])
+  rpcMocks.getInherentsByBatchNumber.mockResolvedValue([
+    true,
+    undefined,
+    [{ type: InherentType.Reward, validatorAddress: ADDRESS_A }],
+  ])
+})
+
+describe('election block conversion', () => {
+  it('converts election slots into a deterministically sorted election set', () => {
+    expect(electionBlockToElectionSet(42, 123_456, {
+      isElectionBlock: true,
+      slots: [
+        { validator: ADDRESS_B, numSlots: 9 },
+        { validator: ADDRESS_A, numSlots: 3 },
+      ],
+    })).toEqual([
+      true,
+      undefined,
+      {
+        epochIndex: 42,
+        electionBlockNumber: 123_456,
+        validators: [
+          { address: ADDRESS_A, numSlots: 3 },
+          { address: ADDRESS_B, numSlots: 9 },
+        ],
+      },
+    ])
+  })
+
+  it('rejects a block that is not an election block', () => {
+    const result = electionBlockToElectionSet(42, 123_456, {
+      isElectionBlock: false,
+      slots: [],
+    })
+
+    expect(result[0]).toBe(false)
+    expect(result[1]).toMatch(/not an election block/i)
+    expect(result[2]).toBeUndefined()
+  })
+
+  it('rejects an election block without a slots array', () => {
+    const result = electionBlockToElectionSet(42, 123_456, {
+      isElectionBlock: true,
+    })
+
+    expect(result[0]).toBe(false)
+    expect(result[1]).toMatch(/slots/i)
+    expect(result[2]).toBeUndefined()
+  })
+})
+
+describe('fetchActivity election set use', () => {
+  it('uses preceding epoch election block for activity epoch election set', async () => {
+    const [ok, , electionSet] = await fetchElectionSet(42)
+
+    expect(ok).toBe(true)
+    expect(rpcMocks.getBlockByNumber).toHaveBeenCalledWith({ blockNumber: 41_000, includeBody: false })
+    expect(electionSet?.electionBlockNumber).toBe(41_000)
+  })
+
+  it('makes no election-block request when an election set is preloaded', async () => {
+    const [ok] = await fetchActivity(42, { electionSet: createElectionSet(42) })
+
+    expect(ok).toBe(true)
+    expect(rpcMocks.getBlockByNumber).not.toHaveBeenCalled()
+  })
+
+  it('makes exactly one election-block request by default', async () => {
+    const [ok] = await fetchActivity(42)
+
+    expect(ok).toBe(true)
+    expect(rpcMocks.getBlockByNumber).toHaveBeenCalledTimes(1)
+    expect(rpcMocks.getBlockByNumber).toHaveBeenCalledWith({ blockNumber: 41_000, includeBody: false })
+  })
+
+  it('rejects an unfinished epoch before fetching activity batches', async () => {
+    rpcMocks.getEpochNumber.mockResolvedValue([true, undefined, 42])
+
+    const [ok, error] = await fetchActivity(42, { electionSet: createElectionSet(42) })
+
+    expect(ok).toBe(false)
+    expect(error).toMatch(/not finished yet/i)
+    expect(rpcMocks.getInherentsByBatchNumber).not.toHaveBeenCalled()
+  })
+
+  it('matches differently formatted inherent addresses to the formatted storage key', async () => {
+    rpcMocks.getInherentsByBatchNumber.mockResolvedValue([
+      true,
+      undefined,
+      [{ type: InherentType.Reward, validatorAddress: ADDRESS_A_COMPACT }],
+    ])
+
+    const [ok, , activity] = await fetchActivity(42, { electionSet: createElectionSet(42) })
+
+    expect(ok).toBe(true)
+    expect(activity?.[ADDRESS_A]?.rewarded).toBe(1)
+    expect(activity?.[ADDRESS_A_COMPACT]).toBeUndefined()
+  })
+
+  it('rejects duplicate canonical addresses in a preloaded election set', async () => {
+    const [ok, error] = await fetchActivity(42, {
+      electionSet: createElectionSet(42, [
+        { address: ADDRESS_A, numSlots: 3 },
+        { address: ADDRESS_A_COMPACT, numSlots: 4 },
+      ]),
+    })
+
+    expect(ok).toBe(false)
+    expect(error).toMatch(/duplicate validator/i)
+    expect(rpcMocks.getInherentsByBatchNumber).not.toHaveBeenCalled()
+  })
+})
+
+describe('fetchEpochs election set isolation', () => {
+  it('does not reuse one preloaded election set for a different epoch', async () => {
+    const results = []
+    const unsafeOptions = { electionSet: createElectionSet(42) } as unknown as FetchEpochsOptions
+
+    for await (const result of fetchEpochs([42, 43], unsafeOptions))
+      results.push(result)
+
+    expect(results).toHaveLength(2)
+    expect(results.every(([ok]) => ok)).toBe(true)
+    expect(rpcMocks.getBlockByNumber).toHaveBeenCalledTimes(2)
+    expect(rpcMocks.getBlockByNumber).toHaveBeenNthCalledWith(1, { blockNumber: 41_000, includeBody: false })
+    expect(rpcMocks.getBlockByNumber).toHaveBeenNthCalledWith(2, { blockNumber: 42_000, includeBody: false })
+  })
+})
diff --git a/packages/nimiq-validator-trustscore/src/fetcher.ts b/packages/nimiq-validator-trustscore/src/fetcher.ts
index 1caca8cc..aa816dde 100644
--- a/packages/nimiq-validator-trustscore/src/fetcher.ts
+++ b/packages/nimiq-validator-trustscore/src/fetcher.ts
@@ -1,12 +1,14 @@
 import type { BaseAlbatrossPolicyOptions } from '@nimiq/utils/albatross-policy'
 import type { ElectionMacroBlock } from 'nimiq-rpc-client-ts/types'
 import type { ActivityBatchProgress } from './sync-progress'
-import type { ElectedValidator, EpochActivity, Result, ResultSync, SnapshotEpoch, UnelectedValidator } from './types'
+import type { ElectedValidator, ElectionSet, EpochActivity, Result, ResultSync, SnapshotEpoch, UnelectedValidator } from './types'
 import { batchAt, BATCHES_PER_EPOCH, electionBlockOf, firstBlockOf, isElectionBlockAt, SLOTS } from '@nimiq/utils/albatross-policy'
 import { getBlockByNumber, getEpochNumber, getInherentsByBatchNumber, getStakersByValidatorAddress, getValidatorByAddress, getValidators } from 'nimiq-rpc-client-ts/http'
 import { InherentType } from 'nimiq-rpc-client-ts/types'
 
-export interface FetchActivityOptions extends Pick<BaseAlbatrossPolicyOptions, 'network'> {
+export interface FetchElectionSetOptions extends Pick<BaseAlbatrossPolicyOptions, 'network'> { }
+
+export interface FetchActivityOptions extends FetchElectionSetOptions {
   /**
    * The maximum number of retries to fetch the activity for a given batch.
    * @default 5
@@ -18,23 +20,83 @@ export interface FetchActivityOptions extends Pick<BaseAlbatrossPolicyOptions, '
    */
   maxBatchSize?: number
   onProgress?: (progress: ActivityBatchProgress) => void
+  electionSet?: ElectionSet
+}
+
+export type FetchEpochsOptions = Omit<FetchActivityOptions, 'electionSet'>
+
+function canonicalAddress(address: string): string {
+  return address.replace(/\s/g, '').toUpperCase()
+}
+
+const STAKING_CONTRACT_ADDRESS = canonicalAddress('NQ07 0000 0000 0000 0000 0000 0000 0000 0000')
+
+export function electionBlockToElectionSet(epochIndex: number, electionBlockNumber: number, block: unknown): ResultSync<ElectionSet> {
+  if (!block || typeof block !== 'object' || !('isElectionBlock' in block) || block.isElectionBlock !== true)
+    return [false, JSON.stringify({ message: 'Block is not an election block', epochIndex, block }), undefined]
+
+  if (!('slots' in block) || !Array.isArray(block.slots))
+    return [false, JSON.stringify({ message: 'Election block has no slots array', epochIndex, block }), undefined]
+
+  const validators: ElectionSet['validators'] = []
+  const seenAddresses = new Set<string>()
+  for (const slot of block.slots) {
+    if (!slot || typeof slot !== 'object' || !('validator' in slot) || typeof slot.validator !== 'string' || !('numSlots' in slot) || typeof slot.numSlots !== 'number')
+      return [false, JSON.stringify({ message: 'Election block contains an invalid slot', epochIndex, slot }), undefined]
+
+    const canonical = canonicalAddress(slot.validator)
+    if (seenAddresses.has(canonical))
+      return [false, JSON.stringify({ message: 'Election block contains a duplicate validator', epochIndex, address: slot.validator }), undefined]
+
+    seenAddresses.add(canonical)
+    validators.push({ address: slot.validator, numSlots: slot.numSlots })
+  }
+
+  validators.sort((a, b) => {
+    const canonicalA = canonicalAddress(a.address)
+    const canonicalB = canonicalAddress(b.address)
+    return canonicalA < canonicalB ? -1 : canonicalA > canonicalB ? 1 : 0
+  })
+
+  return [true, undefined, { epochIndex, electionBlockNumber, validators }]
+}
+
+export async function fetchElectionSet(epochIndex: number, options: FetchElectionSetOptions = {}): Result<ElectionSet> {
+  const { network = 'mainnet' } = options
+  const electionBlockNumber = electionBlockOf(epochIndex - 1, { network })
+  if (electionBlockNumber === undefined || electionBlockNumber === null)
+    return [false, JSON.stringify({ message: 'Unable to determine election block', epochIndex, network }), undefined]
+
+  const [isBlockOk, errorBlockNumber, block] = await getBlockByNumber({ blockNumber: electionBlockNumber, includeBody: false })
+  if (!isBlockOk)
+    return [false, errorBlockNumber, undefined]
+
+  return electionBlockToElectionSet(epochIndex, electionBlockNumber, block)
 }
 
 /**
- * For a given block number, fetches the validator slots assignation.
- * The block number MUST be an election block otherwise it will return an error result.
+ * Fetches validator activity for a completed epoch.
  */
 export async function fetchActivity(epochIndex: number, options: FetchActivityOptions = {}): Result<EpochActivity> {
   const { maxRetries = 5, network = 'mainnet', maxBatchSize: _maxBatchSize = 120 } = options
-  // Epochs start at 1, but election block is the first block of the epoch
-  const electionBlock = electionBlockOf(epochIndex, { network })!
-  const [isBlockOk, errorBlockNumber, block] = await getBlockByNumber({ blockNumber: electionBlock, includeBody: false })
-  if (!isBlockOk) {
-    console.error(JSON.stringify({ epochIndex, errorBlockNumber, block }))
-    return [false, errorBlockNumber, undefined]
+  let electionSet = options.electionSet
+  if (!electionSet) {
+    const [electionSetOk, electionSetError, fetchedElectionSet] = await fetchElectionSet(epochIndex, { network })
+    if (!electionSetOk)
+      return [false, electionSetError, undefined]
+    electionSet = fetchedElectionSet
+  }
+  if (electionSet.epochIndex !== epochIndex)
+    return [false, JSON.stringify({ message: 'Election set epoch does not match requested epoch', epochIndex, electionSetEpochIndex: electionSet.epochIndex }), undefined]
+  const expectedElectionBlockNumber = electionBlockOf(epochIndex - 1, { network })
+  if (expectedElectionBlockNumber === undefined || expectedElectionBlockNumber === null || electionSet.electionBlockNumber !== expectedElectionBlockNumber) {
+    return [false, JSON.stringify({
+      message: 'Election set block does not match requested epoch',
+      epochIndex,
+      electionBlockNumber: electionSet.electionBlockNumber,
+      expectedElectionBlockNumber,
+    }), undefined]
   }
-  if (!('isElectionBlock' in block))
-    return [false, JSON.stringify({ message: 'Block is not election block', epochIndex, block }), undefined]
 
   const [isEpochOk, errorEpochNumber, currentEpochNumber] = await getEpochNumber()
   if (!isEpochOk) {
@@ -51,11 +113,17 @@ export async function fetchActivity(epochIndex: number, options: FetchActivityOp
 
   // Initialize the list of validators and their activity in the epoch
   const epochActivity: EpochActivity = {}
-  for (const { numSlots: likelihood, validator } of (block as ElectionMacroBlock).slots) {
+  const activityAddressByCanonical = new Map<string, string>()
+  for (const { address, numSlots: likelihood } of electionSet.validators) {
+    const canonical = canonicalAddress(address)
+    if (activityAddressByCanonical.has(canonical))
+      return [false, JSON.stringify({ message: 'Election set contains a duplicate validator', epochIndex, address }), undefined]
+
     const dominanceRatioViaSlots = likelihood / SLOTS
     const balance = -1
     const dominanceRatioViaBalance = -1
-    epochActivity[validator] = { address: validator, likelihood, missed: 0, rewarded: 0, dominanceRatioViaBalance, dominanceRatioViaSlots, balance, elected: true, stakers: 0 } as ElectedValidator
+    activityAddressByCanonical.set(canonical, address)
+    epochActivity[address] = { address, likelihood, missed: 0, rewarded: 0, dominanceRatioViaBalance, dominanceRatioViaSlots, balance, elected: true, stakers: 0 } as ElectedValidator
   }
 
   const maxBatchSize = _maxBatchSize
@@ -76,14 +144,11 @@ export async function fetchActivity(epochIndex: number, options: FetchActivityOp
       }
 
       for (const { type, validatorAddress } of inherents) {
-        const isStakingAddress = validatorAddress === 'NQ07 0000 0000 0000 0000 0000 0000 0000 0000'
-        const validatorsExists = !!epochActivity[validatorAddress]
-        const validatorIsElected = validatorsExists && epochActivity[validatorAddress]?.elected
-        if (isStakingAddress || !validatorIsElected || !validatorsExists)
-          continue
-
-        const activity = epochActivity[validatorAddress]
-        if (!activity)
+        const canonicalValidatorAddress = canonicalAddress(validatorAddress)
+        const isStakingAddress = canonicalValidatorAddress === STAKING_CONTRACT_ADDRESS
+        const activityAddress = activityAddressByCanonical.get(canonicalValidatorAddress)
+        const activity = activityAddress ? epochActivity[activityAddress] : undefined
+        if (isStakingAddress || !activity?.elected)
           continue
         if (type === InherentType.Reward)
           activity.rewarded++
@@ -157,9 +222,12 @@ type FetchFunctionResult = AsyncGenerator<ResultSync<{
  * @param epochsIndexes - An array of epoch block numbers to fetch the activities for.
  * @returns An asynchronous generator yielding objects containing the address, epoch index, and activity.
  */
-export async function* fetchEpochs(epochsIndexes: number[], options: FetchActivityOptions = {}): FetchFunctionResult {
+export async function* fetchEpochs(epochsIndexes: number[], options: FetchEpochsOptions = {}): FetchFunctionResult {
+  const activityOptions: FetchActivityOptions = { ...options }
+  delete activityOptions.electionSet
+
   for (const epochIndex of epochsIndexes) {
-    const [activityOk, activityError, activities] = await fetchActivity(epochIndex, options)
+    const [activityOk, activityError, activities] = await fetchActivity(epochIndex, activityOptions)
 
     if (!activityOk) {
       yield [false, `Error fetching activity for epoch ${epochIndex}: ${activityError}`, undefined]
diff --git a/packages/nimiq-validator-trustscore/src/score-v2.test.ts b/packages/nimiq-validator-trustscore/src/score-v2.test.ts
new file mode 100644
index 00000000..12dca323
--- /dev/null
+++ b/packages/nimiq-validator-trustscore/src/score-v2.test.ts
@@ -0,0 +1,269 @@
+import { describe, expect, it } from 'vitest'
+import { ValidatorEpochStatus } from './epoch-status'
+import {
+  computeScoreV2,
+  getLongTermAvailabilityV2,
+  getRecentAvailabilityV2,
+  getReliabilityV2,
+} from './score-v2'
+
+function epoch(
+  epochNumber: number,
+  status: ValidatorEpochStatus,
+  rewarded = 720,
+  missed = 0,
+) {
+  return { epochNumber, status, rewarded, missed }
+}
+
+describe('score v2 recent availability', () => {
+  it('maps the 14 server-supplied completed epochs, excluding random non-election', () => {
+    const epochs = [
+      epoch(14, ValidatorEpochStatus.ElectedOnline),
+      epoch(13, ValidatorEpochStatus.ElectedDegraded, 711, 9),
+      epoch(12, ValidatorEpochStatus.ElectedFailedOrOffline, 0, 720),
+      epoch(11, ValidatorEpochStatus.InactiveByChoiceOrRemoved, 0, 0),
+      epoch(10, ValidatorEpochStatus.NotElectedRandomness, -1, -1),
+      epoch(9, ValidatorEpochStatus.ElectedOnline),
+      epoch(8, ValidatorEpochStatus.ElectedDegraded, 711, 9),
+      epoch(7, ValidatorEpochStatus.ElectedFailedOrOffline, 0, 720),
+      epoch(6, ValidatorEpochStatus.InactiveByChoiceOrRemoved, 0, 0),
+      epoch(5, ValidatorEpochStatus.ElectedOnline),
+      epoch(4, ValidatorEpochStatus.ElectedOnline),
+      epoch(3, ValidatorEpochStatus.ElectedOnline),
+      epoch(2, ValidatorEpochStatus.ElectedOnline),
+      epoch(1, ValidatorEpochStatus.ElectedOnline),
+    ]
+
+    expect(getRecentAvailabilityV2(epochs)).toEqual([true, undefined, 0.6923076923076923])
+  })
+
+  it('fails rather than treating unknown activity as online', () => {
+    const [success, error, availability] = getRecentAvailabilityV2([
+      epoch(2, ValidatorEpochStatus.ElectedOnline),
+      epoch(1, ValidatorEpochStatus.UnknownPlaceholder, -1, -1),
+    ])
+
+    expect(success).toBe(false)
+    expect(error).toBeTypeOf('string')
+    expect(availability).toBeUndefined()
+  })
+
+  it('fails when every completed epoch is excluded random non-election', () => {
+    const [success, error, availability] = getRecentAvailabilityV2([
+      epoch(2, ValidatorEpochStatus.NotElectedRandomness, -1, -1),
+      epoch(1, ValidatorEpochStatus.NotElectedRandomness, -1, -1),
+    ])
+
+    expect(success).toBe(false)
+    expect(error).toBeTypeOf('string')
+    expect(availability).toBeUndefined()
+  })
+
+  it('treats explicit inactivity sentinels as zero availability', () => {
+    expect(getRecentAvailabilityV2([
+      epoch(1, ValidatorEpochStatus.InactiveByChoiceOrRemoved, -1, -1),
+    ])).toEqual([true, undefined, 0])
+  })
+})
+
+describe('score v2 long-term availability', () => {
+  it('excludes random non-election and weights newest eligible epochs first before quadratic smoothing', () => {
+    const [success, error, availability] = getLongTermAvailabilityV2([
+      epoch(1, ValidatorEpochStatus.ElectedFailedOrOffline, 0, 720),
+      epoch(3, ValidatorEpochStatus.NotElectedRandomness, -1, -1),
+      epoch(2, ValidatorEpochStatus.ElectedOnline),
+    ])
+
+    expect(success).toBe(true)
+    expect(error).toBeUndefined()
+    expect(availability).toBeCloseTo(0.8163265306122449, 12)
+  })
+
+  it('scores elected offline and explicit inactivity as zero availability', () => {
+    expect(getLongTermAvailabilityV2([
+      epoch(2, ValidatorEpochStatus.ElectedFailedOrOffline, 0, 720),
+      epoch(1, ValidatorEpochStatus.InactiveByChoiceOrRemoved, 0, 0),
+    ])).toEqual([true, undefined, 0])
+  })
+
+  it('treats explicit inactivity sentinels as zero availability', () => {
+    expect(getLongTermAvailabilityV2([
+      epoch(1, ValidatorEpochStatus.InactiveByChoiceOrRemoved, -1, -1),
+    ])).toEqual([true, undefined, 0])
+  })
+})
+
+describe('score v2 reliability', () => {
+  it('uses normalized zero-based positions and epoch recency, independent of input order', () => {
+    const [,, newestDegraded] = getReliabilityV2([
+      epoch(2, ValidatorEpochStatus.ElectedOnline),
+      epoch(10_000, ValidatorEpochStatus.ElectedDegraded, 3, 1),
+    ])
+    const [,, oldestDegraded] = getReliabilityV2([
+      epoch(10_000, ValidatorEpochStatus.ElectedOnline),
+      epoch(2, ValidatorEpochStatus.ElectedDegraded, 3, 1),
+    ])
+
+    if (newestDegraded === undefined || oldestDegraded === undefined)
+      throw new Error('Expected reliability values')
+
+    expect(newestDegraded).toBeCloseTo(0.5798100240755055, 6)
+    expect(oldestDegraded).toBeCloseTo(0.6474652824103583, 6)
+    expect(newestDegraded).toBeLessThan(oldestDegraded)
+  })
+
+  it('reduces reliability when a degraded elected epoch misses blocks', () => {
+    expect(getReliabilityV2([
+      epoch(1, ValidatorEpochStatus.ElectedDegraded, 3, 1),
+    ])).toEqual([true, undefined, expect.closeTo(0.4230468128842918, 7)])
+  })
+
+  it('excludes full offline epochs so availability owns the outage penalty', () => {
+    expect(getReliabilityV2([
+      epoch(3, ValidatorEpochStatus.ElectedFailedOrOffline, 0, 720),
+      epoch(2, ValidatorEpochStatus.ElectedOnline),
+      epoch(1, ValidatorEpochStatus.InactiveByChoiceOrRemoved, 0, 0),
+    ])).toEqual([true, undefined, 1])
+  })
+
+  it('excludes explicit inactivity sentinels from reliability', () => {
+    expect(getReliabilityV2([
+      epoch(2, ValidatorEpochStatus.ElectedOnline),
+      epoch(1, ValidatorEpochStatus.InactiveByChoiceOrRemoved, -1, -1),
+    ])).toEqual([true, undefined, 1])
+  })
+})
+
+describe('score v2 validation', () => {
+  it('fails long-term and reliability scoring on unknown activity', () => {
+    for (const result of [
+      getLongTermAvailabilityV2([
+        epoch(1, ValidatorEpochStatus.UnknownPlaceholder, -1, -1),
+      ]),
+      getReliabilityV2([
+        epoch(1, ValidatorEpochStatus.UnknownPlaceholder, -1, -1),
+      ]),
+    ]) {
+      expect(result[0]).toBe(false)
+      expect(result[1]).toBeTypeOf('string')
+      expect(result[2]).toBeUndefined()
+    }
+  })
+
+  it('fails when filtering leaves no usable data', () => {
+    for (const result of [
+      getLongTermAvailabilityV2([
+        epoch(1, ValidatorEpochStatus.NotElectedRandomness, -1, -1),
+      ]),
+      getReliabilityV2([]),
+    ]) {
+      expect(result[0]).toBe(false)
+      expect(result[1]).toBeTypeOf('string')
+      expect(result[2]).toBeUndefined()
+    }
+  })
+
+  it('rejects invalid weight factors and invalid production counters', () => {
+    expect(getLongTermAvailabilityV2([
+      epoch(1, ValidatorEpochStatus.ElectedOnline),
+    ], { weightFactor: 1.1 })[0]).toBe(false)
+
+    expect(getReliabilityV2([
+      epoch(1, ValidatorEpochStatus.ElectedOnline),
+    ], { weightFactor: -0.1 })[0]).toBe(false)
+
+    expect(getReliabilityV2([
+      epoch(1, ValidatorEpochStatus.ElectedOnline, -1, -1),
+    ])[0]).toBe(false)
+  })
+
+  it('returns only finite values within the unit interval', () => {
+    const results = [
+      getRecentAvailabilityV2([
+        epoch(2, ValidatorEpochStatus.ElectedOnline),
+        epoch(1, ValidatorEpochStatus.ElectedFailedOrOffline, 0, 720),
+      ]),
+      getLongTermAvailabilityV2([
+        epoch(2, ValidatorEpochStatus.ElectedOnline),
+        epoch(1, ValidatorEpochStatus.ElectedFailedOrOffline, 0, 720),
+      ]),
+      getReliabilityV2([
+        epoch(2, ValidatorEpochStatus.ElectedOnline),
+        epoch(1, ValidatorEpochStatus.ElectedDegraded, 3, 1),
+      ]),
+    ]
+
+    for (const [success, error, value] of results) {
+      expect(success).toBe(true)
+      expect(error).toBeUndefined()
+      if (value === undefined)
+        throw new Error('Expected score value')
+      expect(Number.isFinite(value)).toBe(true)
+      expect(value).toBeGreaterThanOrEqual(0)
+      expect(value).toBeLessThanOrEqual(1)
+    }
+  })
+})
+
+describe('score v2 outage regression', () => {
+  it('blends four recent outages with separate healthy long-term history near the outage target', () => {
+    const recentEpochs = [
+      epoch(29, ValidatorEpochStatus.ElectedFailedOrOffline, 0, 720),
+      epoch(28, ValidatorEpochStatus.ElectedFailedOrOffline, 0, 720),
+      epoch(27, ValidatorEpochStatus.ElectedFailedOrOffline, 0, 720),
+      epoch(26, ValidatorEpochStatus.ElectedFailedOrOffline, 0, 720),
+      epoch(25, ValidatorEpochStatus.ElectedOnline),
+      epoch(24, ValidatorEpochStatus.ElectedOnline),
+      epoch(23, ValidatorEpochStatus.ElectedOnline),
+      epoch(22, ValidatorEpochStatus.ElectedOnline),
+      epoch(21, ValidatorEpochStatus.ElectedOnline),
+      epoch(20, ValidatorEpochStatus.ElectedOnline),
+      epoch(19, ValidatorEpochStatus.ElectedOnline),
+      epoch(18, ValidatorEpochStatus.ElectedOnline),
+      epoch(17, ValidatorEpochStatus.ElectedOnline),
+      epoch(16, ValidatorEpochStatus.ElectedOnline),
+      epoch(15, ValidatorEpochStatus.ElectedOnline),
+      epoch(14, ValidatorEpochStatus.ElectedOnline),
+      epoch(13, ValidatorEpochStatus.ElectedOnline),
+      epoch(12, ValidatorEpochStatus.ElectedOnline),
+      epoch(11, ValidatorEpochStatus.ElectedOnline),
+      epoch(10, ValidatorEpochStatus.ElectedOnline),
+      epoch(9, ValidatorEpochStatus.ElectedOnline),
+      epoch(8, ValidatorEpochStatus.ElectedOnline),
+      epoch(7, ValidatorEpochStatus.ElectedOnline),
+      epoch(6, ValidatorEpochStatus.ElectedOnline),
+      epoch(5, ValidatorEpochStatus.ElectedOnline),
+      epoch(4, ValidatorEpochStatus.ElectedOnline),
+      epoch(3, ValidatorEpochStatus.ElectedOnline),
+      epoch(2, ValidatorEpochStatus.ElectedOnline),
+      epoch(1, ValidatorEpochStatus.ElectedOnline),
+    ]
+    const longTermEpochs = [
+      epoch(3, ValidatorEpochStatus.ElectedOnline),
+      epoch(2, ValidatorEpochStatus.ElectedOnline),
+      epoch(1, ValidatorEpochStatus.ElectedOnline),
+    ]
+
+    const [success, error, score] = computeScoreV2({
+      dominance: { dominanceRatio: 0.01 },
+      recentEpochs,
+      longTermEpochs,
+    })
+
+    expect(success).toBe(true)
+    expect(error).toBeUndefined()
+    expect(score).toBeDefined()
+    expect(score?.recentAvailability).toBeCloseTo(0.8620689655172413, 12)
+    expect(score?.longTermAvailability).toBe(1)
+    expect(score?.availability).toBeCloseTo(0.9310344827586207, 12)
+    expect(score?.total).toBeGreaterThanOrEqual(0.9)
+    expect(score?.total).toBeLessThanOrEqual(0.94)
+
+    for (const value of Object.values(score ?? {})) {
+      expect(Number.isFinite(value)).toBe(true)
+      expect(value).toBeGreaterThanOrEqual(0)
+      expect(value).toBeLessThanOrEqual(1)
+    }
+  })
+})
diff --git a/packages/nimiq-validator-trustscore/src/score-v2.ts b/packages/nimiq-validator-trustscore/src/score-v2.ts
new file mode 100644
index 00000000..97fe6ccf
--- /dev/null
+++ b/packages/nimiq-validator-trustscore/src/score-v2.ts
@@ -0,0 +1,255 @@
+import type {
+  ResultSync,
+  ScoreV2Epoch,
+  ScoreV2Params,
+  ScoreV2Values,
+} from './types'
+import { ValidatorEpochStatus } from './epoch-status'
+import { getDominance } from './score'
+
+interface WeightOptions {
+  weightFactor?: number
+}
+
+interface ReliabilityOptions extends WeightOptions {
+  curveCenter?: number
+}
+
+function validateWeightFactor(weightFactor: number): string | undefined {
+  if (!Number.isFinite(weightFactor) || weightFactor < 0 || weightFactor > 1)
+    return `Invalid weight factor: ${weightFactor}`
+}
+
+function validateEpochs(epochs: readonly ScoreV2Epoch[]): string | undefined {
+  if (!Array.isArray(epochs) || epochs.length === 0)
+    return 'No epochs supplied'
+
+  const epochNumbers = new Set<number>()
+
+  for (const epoch of epochs) {
+    if (!Number.isInteger(epoch.epochNumber) || epoch.epochNumber < 0)
+      return `Invalid epoch number: ${epoch.epochNumber}`
+    if (epochNumbers.has(epoch.epochNumber))
+      return `Duplicate epoch number: ${epoch.epochNumber}`
+    epochNumbers.add(epoch.epochNumber)
+
+    if (!Number.isFinite(epoch.rewarded) || !Number.isInteger(epoch.rewarded))
+      return `Invalid rewarded counter for epoch ${epoch.epochNumber}: ${epoch.rewarded}`
+    if (!Number.isFinite(epoch.missed) || !Number.isInteger(epoch.missed))
+      return `Invalid missed counter for epoch ${epoch.epochNumber}: ${epoch.missed}`
+
+    switch (epoch.status) {
+      case ValidatorEpochStatus.NotElectedRandomness:
+        if (epoch.rewarded !== -1 || epoch.missed !== -1)
+          return `Invalid random non-election counters for epoch ${epoch.epochNumber}`
+        break
+      case ValidatorEpochStatus.ElectedOnline:
+      case ValidatorEpochStatus.ElectedDegraded:
+        if (epoch.rewarded < 0 || epoch.missed < 0 || epoch.rewarded + epoch.missed <= 0)
+          return `Invalid elected counters for epoch ${epoch.epochNumber}`
+        break
+      case ValidatorEpochStatus.ElectedFailedOrOffline:
+        if (epoch.rewarded < 0 || epoch.missed < 0)
+          return `Invalid availability counters for epoch ${epoch.epochNumber}`
+        break
+      case ValidatorEpochStatus.InactiveByChoiceOrRemoved:
+        if (!(
+          (epoch.rewarded === -1 && epoch.missed === -1)
+          || (epoch.rewarded === 0 && epoch.missed === 0)
+        )) {
+          return `Invalid inactive counters for epoch ${epoch.epochNumber}`
+        }
+        break
+      case ValidatorEpochStatus.UnknownPlaceholder:
+        return `Unknown activity for epoch ${epoch.epochNumber}`
+      default:
+        return `Invalid status for epoch ${epoch.epochNumber}: ${String(epoch.status)}`
+    }
+  }
+}
+
+function validateScoreValue(name: string, value: number): ResultSync<number> {
+  if (!Number.isFinite(value) || value < 0 || value > 1)
+    return [false, `Invalid ${name}: ${value}`, undefined]
+  return [true, undefined, value]
+}
+
+function newestFirst(epochs: readonly ScoreV2Epoch[]): ScoreV2Epoch[] {
+  return [...epochs].sort((a, b) => b.epochNumber - a.epochNumber)
+}
+
+export function getRecentAvailabilityV2(
+  epochs: readonly ScoreV2Epoch[],
+): ResultSync<number> {
+  const epochError = validateEpochs(epochs)
+  if (epochError)
+    return [false, epochError, undefined]
+
+  let available = 0
+  let eligible = 0
+
+  for (const epoch of epochs) {
+    switch (epoch.status) {
+      case ValidatorEpochStatus.NotElectedRandomness:
+        break
+      case ValidatorEpochStatus.ElectedOnline:
+      case ValidatorEpochStatus.ElectedDegraded:
+        available++
+        eligible++
+        break
+      case ValidatorEpochStatus.ElectedFailedOrOffline:
+      case ValidatorEpochStatus.InactiveByChoiceOrRemoved:
+        eligible++
+        break
+    }
+  }
+
+  if (eligible === 0)
+    return [false, 'No eligible epochs for recent availability', undefined]
+
+  return validateScoreValue('recent availability', available / eligible)
+}
+
+export function getLongTermAvailabilityV2(
+  epochs: readonly ScoreV2Epoch[],
+  options: WeightOptions = {},
+): ResultSync<number> {
+  const { weightFactor = 0.5 } = options
+  const weightError = validateWeightFactor(weightFactor)
+  if (weightError)
+    return [false, weightError, undefined]
+
+  const epochError = validateEpochs(epochs)
+  if (epochError)
+    return [false, epochError, undefined]
+
+  const eligible = newestFirst(epochs).filter(
+    epoch => epoch.status !== ValidatorEpochStatus.NotElectedRandomness,
+  )
+  if (eligible.length === 0)
+    return [false, 'No eligible epochs for long-term availability', undefined]
+
+  let weightedSum = 0
+  let weightTotal = 0
+
+  for (const [position, epoch] of eligible.entries()) {
+    const weight = 1 - weightFactor * position / eligible.length
+    const available = epoch.status === ValidatorEpochStatus.ElectedOnline
+      || epoch.status === ValidatorEpochStatus.ElectedDegraded
+      ? 1
+      : 0
+
+    weightedSum += weight * available
+    weightTotal += weight
+  }
+
+  if (!Number.isFinite(weightTotal) || weightTotal <= 0)
+    return [false, `Invalid long-term availability weight total: ${weightTotal}`, undefined]
+
+  const movingAverage = weightedSum / weightTotal
+  const availability = -(movingAverage ** 2) + 2 * movingAverage
+  return validateScoreValue('long-term availability', availability)
+}
+
+export function getReliabilityV2(
+  epochs: readonly ScoreV2Epoch[],
+  options: ReliabilityOptions = {},
+): ResultSync<number> {
+  const { weightFactor = 0.5, curveCenter = -0.16 } = options
+  const weightError = validateWeightFactor(weightFactor)
+  if (weightError)
+    return [false, weightError, undefined]
+  if (!Number.isFinite(curveCenter) || curveCenter > 0)
+    return [false, `Invalid reliability curve center: ${curveCenter}`, undefined]
+
+  const epochError = validateEpochs(epochs)
+  if (epochError)
+    return [false, epochError, undefined]
+
+  const electedPerformance = newestFirst(epochs).filter(
+    epoch => epoch.status === ValidatorEpochStatus.ElectedOnline
+      || epoch.status === ValidatorEpochStatus.ElectedDegraded,
+  )
+
+  if (electedPerformance.length === 0) {
+    const availabilityOwnsPenalty = epochs.some(
+      epoch => epoch.status === ValidatorEpochStatus.ElectedFailedOrOffline
+        || epoch.status === ValidatorEpochStatus.InactiveByChoiceOrRemoved,
+    )
+    return availabilityOwnsPenalty
+      ? [true, undefined, 1]
+      : [false, 'No eligible epochs for reliability', undefined]
+  }
+
+  let numerator = 0
+  let denominator = 0
+
+  for (const [position, epoch] of electedPerformance.entries()) {
+    const weight = 1 - weightFactor * position / electedPerformance.length
+    const reliability = epoch.rewarded / (epoch.rewarded + epoch.missed)
+    numerator += weight * reliability
+    denominator += weight
+  }
+
+  if (!Number.isFinite(denominator) || denominator <= 0)
+    return [false, `Invalid reliability weight total: ${denominator}`, undefined]
+
+  const reliability = numerator / denominator
+  if (reliability === 0 || reliability === 1)
+    return [true, undefined, reliability]
+
+  const discriminant = -(reliability ** 2)
+    + 2 * curveCenter * reliability
+    + (curveCenter - 1) ** 2
+  if (!Number.isFinite(discriminant) || discriminant < 0)
+    return [false, `Invalid reliability curve discriminant: ${discriminant}`, undefined]
+
+  const curvedReliability = -curveCenter + 1 - Math.sqrt(discriminant)
+  return validateScoreValue('reliability', curvedReliability)
+}
+
+export function computeScoreV2(params: ScoreV2Params): ResultSync<ScoreV2Values> {
+  const [dominanceSuccess, dominanceError, dominance] = getDominance(params.dominance)
+  if (!dominanceSuccess)
+    return [false, dominanceError, undefined]
+  const validDominance = validateScoreValue('dominance', dominance)
+  if (!validDominance[0])
+    return validDominance
+
+  const [recentSuccess, recentError, recentAvailability] = getRecentAvailabilityV2(params.recentEpochs)
+  if (!recentSuccess)
+    return [false, recentError, undefined]
+
+  const [longTermSuccess, longTermError, longTermAvailability] = getLongTermAvailabilityV2(
+    params.longTermEpochs,
+    params.longTermAvailability,
+  )
+  if (!longTermSuccess)
+    return [false, longTermError, undefined]
+
+  const [reliabilitySuccess, reliabilityError, reliability] = getReliabilityV2(
+    params.longTermEpochs,
+    params.reliability,
+  )
+  if (!reliabilitySuccess)
+    return [false, reliabilityError, undefined]
+
+  const availability = 0.5 * longTermAvailability + 0.5 * recentAvailability
+  const validAvailability = validateScoreValue('availability', availability)
+  if (!validAvailability[0])
+    return validAvailability
+
+  const total = dominance * availability * reliability
+  const validTotal = validateScoreValue('total score', total)
+  if (!validTotal[0])
+    return validTotal
+
+  return [true, undefined, {
+    dominance,
+    recentAvailability,
+    longTermAvailability,
+    availability,
+    reliability,
+    total,
+  }]
+}
diff --git a/packages/nimiq-validator-trustscore/src/types.ts b/packages/nimiq-validator-trustscore/src/types.ts
index a6f9a480..9ada9a3e 100644
--- a/packages/nimiq-validator-trustscore/src/types.ts
+++ b/packages/nimiq-validator-trustscore/src/types.ts
@@ -1,3 +1,5 @@
+import type { ValidatorEpochStatus } from './epoch-status'
+
 export enum ValidatorEpochState {
   Active = 1,
   Inactive = 0,
@@ -96,6 +98,12 @@ export interface SnapshotEpoch {
   validators: (UnelectedValidator | ElectedValidator)[]
 }
 
+export interface ElectionSet {
+  epochIndex: number
+  electionBlockNumber: number
+  validators: Array<{ address: string, numSlots: number }>
+}
+
 // A map of validator addresses to their activities in a single epoch
 export type EpochActivity<T = ElectedValidator | UnelectedValidator> = Record<string, T>
 
@@ -104,6 +112,31 @@ export type EpochsActivities<T = ElectedValidator | UnelectedValidator> = Record
 
 export interface ScoreValues { availability: number, reliability: number, dominance: number, total: number }
 
+export interface ScoreV2Epoch {
+  epochNumber: number
+  status: ValidatorEpochStatus
+  rewarded: number
+  missed: number
+}
+
+export interface ScoreV2Params {
+  dominance: ScoreParams['dominance']
+  recentEpochs: readonly ScoreV2Epoch[]
+  longTermEpochs: readonly ScoreV2Epoch[]
+  longTermAvailability?: {
+    weightFactor?: number
+  }
+  reliability?: {
+    weightFactor?: number
+    curveCenter?: number
+  }
+}
+
+export interface ScoreV2Values extends ScoreValues {
+  recentAvailability: number
+  longTermAvailability: number
+}
+
 export interface Range {
   /**
    * The head number when the range was created.
diff --git a/server/api/[version]/status.get.test.ts b/server/api/[version]/status.get.test.ts
new file mode 100644
index 00000000..aa2ef6af
--- /dev/null
+++ b/server/api/[version]/status.get.test.ts
@@ -0,0 +1,131 @@
+import { afterAll, beforeEach, describe, expect, it, vi } from 'vitest'
+
+const mocks = vi.hoisted(() => ({
+  categorizeValidatorsSnapshotEpoch: vi.fn(),
+  getActivityEpochMarkers: vi.fn(),
+  getBlockNumber: vi.fn(),
+  getLatestScoreState: vi.fn(),
+  getRange: vi.fn(),
+  getRpcUrl: vi.fn(),
+  initRpcClient: vi.fn(),
+}))
+
+vi.mock('nimiq-rpc-client-ts/client', () => ({
+  initRpcClient: mocks.initRpcClient,
+}))
+
+vi.mock('nimiq-rpc-client-ts/http', () => ({
+  getBlockNumber: mocks.getBlockNumber,
+}))
+
+vi.mock('nimiq-validator-trustscore/range', () => ({
+  getRange: mocks.getRange,
+}))
+
+vi.mock('~~/server/utils/rpc', () => ({
+  getRpcUrl: mocks.getRpcUrl,
+}))
+
+vi.stubGlobal('categorizeValidatorsSnapshotEpoch', mocks.categorizeValidatorsSnapshotEpoch)
+vi.stubGlobal('createError', (error: unknown) => error instanceof Error ? error : new Error(String(error)))
+vi.stubGlobal('defineCachedEventHandler', (handler: unknown) => handler)
+vi.stubGlobal('getActivityEpochMarkers', mocks.getActivityEpochMarkers)
+vi.stubGlobal('getLatestScoreState', mocks.getLatestScoreState)
+vi.stubGlobal('getValidatedQuery', async () => ({ 'score-version': 2 }))
+vi.stubGlobal('useSafeRuntimeConfig', () => ({
+  scoreV2Mode: 'off',
+  public: {
+    nimiqNetwork: 'test-albatross',
+  },
+}))
+
+type StatusHandler = (event: unknown) => Promise<Record<string, unknown>>
+
+let statusHandler: StatusHandler
+
+beforeEach(async () => {
+  mocks.categorizeValidatorsSnapshotEpoch.mockReset()
+  mocks.getActivityEpochMarkers.mockReset()
+  mocks.getBlockNumber.mockReset()
+  mocks.getLatestScoreState.mockReset()
+  mocks.getRange.mockReset()
+  mocks.getRpcUrl.mockReset()
+  mocks.initRpcClient.mockReset()
+
+  mocks.getRpcUrl.mockReturnValue('https://rpc.invalid')
+  mocks.getActivityEpochMarkers.mockResolvedValue([
+    {
+      epochNumber: 10,
+      status: 'finalized',
+      startedAt: '2026-07-29T08:00:00.000Z',
+      finalizedAt: '2026-07-29T08:05:00.000Z',
+      lastError: null,
+    },
+    {
+      epochNumber: 11,
+      status: 'failed',
+      startedAt: '2026-07-29T08:00:00.000Z',
+      finalizedAt: null,
+      lastError: 'RPC unavailable',
+    },
+    {
+      epochNumber: 12,
+      status: 'syncing',
+      startedAt: '2026-07-29T08:00:00.000Z',
+      finalizedAt: null,
+      lastError: null,
+    },
+  ])
+  mocks.getLatestScoreState.mockImplementation(async (scoreVersion: number) => {
+    expect(scoreVersion).toBe(2)
+    return { epochNumber: 10, dataStatus: 'complete' }
+  })
+  mocks.getRange.mockResolvedValue([false, 'range RPC unavailable', undefined])
+  mocks.getBlockNumber.mockResolvedValue([false, 'head RPC unavailable', undefined])
+  mocks.categorizeValidatorsSnapshotEpoch.mockResolvedValue([
+    false,
+    'snapshot RPC unavailable',
+    undefined,
+  ])
+
+  vi.resetModules()
+  statusHandler = (await import('./status.get')).default as StatusHandler
+})
+
+afterAll(() => {
+  vi.unstubAllGlobals()
+})
+
+describe('status API live failure isolation', () => {
+  it('returns stored marker and selected-version score status when every optional live RPC fails', async () => {
+    const payload = await statusHandler({})
+
+    expect(payload).toMatchObject({
+      latestCompletedEpoch: 12,
+      latestFinalizedEpoch: 10,
+      failedEpochs: [
+        expect.objectContaining({ epochNumber: 11, lastError: 'RPC unavailable' }),
+      ],
+      syncingEpochs: [
+        expect.objectContaining({ epochNumber: 12 }),
+      ],
+      activeScoreVersion: 1,
+      selectedScoreVersion: 2,
+      latestScoreEpoch: 10,
+      scoreStatus: 'stale',
+      recentCoverage: null,
+      longTermCoverage: null,
+      missingEpochs: null,
+      range: null,
+      validators: null,
+      blockchain: {
+        network: 'test-albatross',
+        headBlockNumber: null,
+      },
+    })
+    expect(mocks.getRange).toHaveBeenCalledOnce()
+    expect(mocks.getBlockNumber).toHaveBeenCalledOnce()
+    expect(mocks.categorizeValidatorsSnapshotEpoch).toHaveBeenCalledOnce()
+    expect(mocks.getLatestScoreState).toHaveBeenCalledWith(2)
+  })
+})
diff --git a/server/api/[version]/status.get.ts b/server/api/[version]/status.get.ts
index 4e348e0a..fdca1af9 100644
--- a/server/api/[version]/status.get.ts
+++ b/server/api/[version]/status.get.ts
@@ -1,7 +1,12 @@
+import type { Range } from 'nimiq-validator-trustscore/types'
+import type { SnapshotEpochValidators } from '~~/server/utils/types'
+import { consola } from 'consola'
 import { initRpcClient } from 'nimiq-rpc-client-ts/client'
 import { getBlockNumber } from 'nimiq-rpc-client-ts/http'
 import { getRange } from 'nimiq-validator-trustscore/range'
 import { getRpcUrl } from '~~/server/utils/rpc'
+import { scoreVersionQuerySchema } from '~~/server/utils/schemas'
+import { deriveMarkerScoreStatus, resolveScoreVersion } from '~~/server/utils/score-api'
 
 /**
  * This endpoint returns the status of the API:
@@ -23,43 +28,96 @@ import { getRpcUrl } from '~~/server/utils/rpc'
  *   - Duration of epoch
  */
 
-export default defineCachedEventHandler(async () => {
-  const rpcUrl = getRpcUrl()
-  if (!rpcUrl)
-    throw createError('No Albatross RPC Node URL')
-  initRpcClient({ url: rpcUrl })
+export default defineCachedEventHandler(async (event) => {
+  const queryParams = await getValidatedQuery(event, scoreVersionQuerySchema.parse)
+  const runtimeConfig = useSafeRuntimeConfig() as ReturnType<typeof useSafeRuntimeConfig> & {
+    scoreV2Mode?: string
+  }
+  const { nimiqNetwork: network } = runtimeConfig.public
+  const scoreV2Mode = runtimeConfig.scoreV2Mode ?? 'off'
+  if (scoreV2Mode !== 'off' && scoreV2Mode !== 'shadow' && scoreV2Mode !== 'active')
+    throw new Error(`Invalid score v2 mode: ${scoreV2Mode}`)
+  const activeScoreVersion = resolveScoreVersion(undefined, scoreV2Mode)
+  const selectedScoreVersion = resolveScoreVersion(queryParams['score-version'], scoreV2Mode)
+  const [markers, latestScore] = await Promise.all([
+    getActivityEpochMarkers(),
+    getLatestScoreState(selectedScoreVersion),
+  ])
 
-  const { nimiqNetwork: network } = useSafeRuntimeConfig().public
+  const rpcUrl = getRpcUrl()
+  let rpcReady = false
+  if (rpcUrl) {
+    try {
+      initRpcClient({ url: rpcUrl })
+      rpcReady = true
+    }
+    catch (error) {
+      consola.warn('Failed to initialize optional status RPC client', error)
+      rpcReady = false
+    }
+  }
 
-  // We get a "window" whose size is determined by the range
-  const [rangeSuccess, errorRange, range] = await getRange({ network })
-  if (!rangeSuccess || !range)
-    throw createError(errorRange || 'No range')
+  let range: Range | null = null
+  let validatorsEpoch: SnapshotEpochValidators | null = null
+  let headBlockNumber: number | null = null
+  if (rpcReady) {
+    try {
+      const [rangeSuccess, , liveRange] = await getRange({ network })
+      if (rangeSuccess && liveRange)
+        range = liveRange
+    }
+    catch (error) {
+      consola.warn('Failed to fetch optional status range', error)
+    }
 
-  const [validatorsSuccess, error, validatorsEpoch] = await categorizeValidatorsSnapshotEpoch()
-  if (!validatorsSuccess || !validatorsEpoch)
-    throw createError(error || 'No data')
+    try {
+      const [validatorsSuccess, , liveValidators] = await categorizeValidatorsSnapshotEpoch()
+      if (validatorsSuccess && liveValidators)
+        validatorsEpoch = liveValidators
+    }
+    catch (error) {
+      consola.warn('Failed to fetch optional validator snapshot', error)
+    }
 
-  const [headBlockOk, errorHeadBlockNumber, headBlockNumber] = await getBlockNumber()
-  if (!headBlockOk)
-    throw createError(errorHeadBlockNumber || 'No head block number')
+    try {
+      const [headBlockOk, , liveHeadBlockNumber] = await getBlockNumber()
+      if (headBlockOk && liveHeadBlockNumber !== undefined)
+        headBlockNumber = liveHeadBlockNumber
+    }
+    catch (error) {
+      consola.warn('Failed to fetch optional head block', error)
+    }
+  }
 
-  const allowedScoreLagEpochs = 1
-  const latestScoreEpoch = await getLatestScoreEpoch()
-  const scoreLagEpochs = getScoreLagEpochs({
-    toEpoch: range.toEpoch,
-    latestScoreEpoch,
+  const markerStatus = deriveMarkerScoreStatus({
+    markers,
+    recentRange: range ? getRecentEpochRange(range) : null,
+    longTermRange: range,
+    activeScoreVersion,
+    selectedScoreVersion,
+    latestScore,
   })
 
-  const missingEpochs = await findMissingEpochs(range)
-  const missingScore = await isScoreMissingWithLag(range, allowedScoreLagEpochs, latestScoreEpoch)
+  const allowedScoreLagEpochs = 1
+  const scoreLagEpochs = range
+    ? getScoreLagEpochs({
+        toEpoch: range.toEpoch,
+        latestScoreEpoch: latestScore?.epochNumber ?? null,
+      })
+    : null
+  const missingScore = range
+    ? await isScoreMissingWithLag(
+        range,
+        allowedScoreLagEpochs,
+        latestScore?.epochNumber ?? null,
+      )
+    : null
 
   return {
     range,
     validators: validatorsEpoch,
-    missingEpochs,
+    ...markerStatus,
     missingScore,
-    latestScoreEpoch,
     scoreLagEpochs,
     allowedScoreLagEpochs,
     blockchain: { network, headBlockNumber },
diff --git a/server/api/[version]/validators/[address].get.ts b/server/api/[version]/validators/[address].get.ts
index be09f9d8..bace1f2c 100644
--- a/server/api/[version]/validators/[address].get.ts
+++ b/server/api/[version]/validators/[address].get.ts
@@ -2,13 +2,23 @@ import { ValidationUtils } from '@nimiq/utils/validation-utils'
 import { initRpcClient } from 'nimiq-rpc-client-ts/client'
 import { z } from 'zod'
 import { getRange } from '~~/packages/nimiq-validator-trustscore/src/range'
+import {
+  calculateActivityCoverage,
+  getActivityEpochMarkers,
+  getRecentEpochRange,
+} from '~~/server/utils/activity-epochs'
 import { getRpcUrl } from '~~/server/utils/rpc'
+import { scoreVersionQuerySchema } from '~~/server/utils/schemas'
+import { resolveScoreVersion } from '~~/server/utils/score-api'
+import { parseScoreV2Mode } from '~~/server/utils/scores'
+import { cachedFetchValidator } from '~~/server/utils/validators'
 
 const paramsSchema = z.object({
   address: z.string(),
 })
 
 export default defineEventHandler(async (event) => {
+  const queryParams = await getValidatedQuery(event, scoreVersionQuerySchema.parse)
   const rpcUrl = getRpcUrl()
   if (!rpcUrl)
     throw createError('No Albatross RPC Node URL')
@@ -17,13 +27,34 @@ export default defineEventHandler(async (event) => {
   const isValid = ValidationUtils.isValidAddress(address)
   if (!isValid)
     throw createError({ statusCode: 400, statusMessage: 'Invalid address format' })
-  const { nimiqNetwork: network } = useSafeRuntimeConfig().public
+  const runtimeConfig = useSafeRuntimeConfig() as ReturnType<typeof useSafeRuntimeConfig> & {
+    scoreV2Mode?: string
+  }
+  const { nimiqNetwork: network } = runtimeConfig.public
 
   const [rangeSuccess, errorRange, range] = await getRange({ network })
   if (!rangeSuccess || !range)
     throw createError({ statusCode: 404, statusMessage: errorRange })
 
-  const [validatorSuccess, errorValidator, validator] = await cachedFetchValidator(event, { address, range })
+  const scoreVersion = resolveScoreVersion(
+    queryParams['score-version'],
+    parseScoreV2Mode(runtimeConfig.scoreV2Mode),
+  )
+  const recentRange = getRecentEpochRange(range)
+  const recentMarkers = await getActivityEpochMarkers(recentRange)
+  const recentCoverage = calculateActivityCoverage(
+    recentRange.fromEpoch,
+    recentRange.toEpoch,
+    recentMarkers
+      .filter(marker => marker.status === 'finalized')
+      .map(marker => marker.epochNumber),
+  ).coverage
+  const [validatorSuccess, errorValidator, validator] = await cachedFetchValidator(event, {
+    address,
+    range,
+    scoreVersion,
+    recentCoverage,
+  })
   if (!validatorSuccess)
     throw createError({ statusCode: 404, statusMessage: errorValidator })
 
diff --git a/server/api/[version]/validators/index.get.ts b/server/api/[version]/validators/index.get.ts
index 9740b4f6..d38671ef 100644
--- a/server/api/[version]/validators/index.get.ts
+++ b/server/api/[version]/validators/index.get.ts
@@ -1,7 +1,14 @@
 import type { FetchValidatorsOptions } from '~~/server/utils/validators'
 import { initRpcClient } from 'nimiq-rpc-client-ts/client'
 import { getRange } from '~~/packages/nimiq-validator-trustscore/src/range'
+import {
+  calculateActivityCoverage,
+  getActivityEpochMarkers,
+  getRecentEpochRange,
+} from '~~/server/utils/activity-epochs'
 import { getRpcUrl } from '~~/server/utils/rpc'
+import { resolveScoreVersion } from '~~/server/utils/score-api'
+import { parseScoreV2Mode } from '~~/server/utils/scores'
 import { cachedFetchValidators, fetchValidators } from '~~/server/utils/validators'
 
 export default defineEventHandler(async (event) => {
@@ -11,13 +18,32 @@ export default defineEventHandler(async (event) => {
   if (!rpcUrl)
     throw createError('No Albatross RPC Node URL')
   initRpcClient({ url: rpcUrl })
-  const { nimiqNetwork: network } = useSafeRuntimeConfig().public
+  const runtimeConfig = useSafeRuntimeConfig() as ReturnType<typeof useSafeRuntimeConfig> & {
+    scoreV2Mode?: string
+  }
+  const { nimiqNetwork: network } = runtimeConfig.public
 
   const [rangeSuccess, errorRange, range] = await getRange({ network })
   if (!rangeSuccess || !range)
     throw createError({ statusCode: 404, statusMessage: errorRange })
 
-  const resolvedParams: FetchValidatorsOptions = { epochNumber: range.toEpoch, ...queryParams }
+  const rolloutMode = parseScoreV2Mode(runtimeConfig.scoreV2Mode)
+  const scoreVersion = resolveScoreVersion(queryParams['score-version'], rolloutMode)
+  const recentRange = getRecentEpochRange(range)
+  const recentMarkers = await getActivityEpochMarkers(recentRange)
+  const recentCoverage = calculateActivityCoverage(
+    recentRange.fromEpoch,
+    recentRange.toEpoch,
+    recentMarkers
+      .filter(marker => marker.status === 'finalized')
+      .map(marker => marker.epochNumber),
+  ).coverage
+  const resolvedParams: FetchValidatorsOptions = {
+    ...queryParams,
+    epochNumber: range.toEpoch,
+    scoreVersion,
+    recentCoverage,
+  }
   const fn = queryParams.force ? fetchValidators : cachedFetchValidators
   const [validatorsSuccess, errorValidators, validators] = await fn(event, resolvedParams)
   if (!validatorsSuccess || !validators)
diff --git a/server/db/migrations/0005_validator_activity_integrity_score_v2.sql b/server/db/migrations/0005_validator_activity_integrity_score_v2.sql
new file mode 100644
index 00000000..9c4cbe75
--- /dev/null
+++ b/server/db/migrations/0005_validator_activity_integrity_score_v2.sql
@@ -0,0 +1,55 @@
+CREATE TABLE `activity_epochs` (
+	`epoch_number` integer PRIMARY KEY NOT NULL,
+	`status` text NOT NULL,
+	`expected_elected_count` integer,
+	`stored_elected_count` integer,
+	`elected_set_hash` text,
+	`attempt_count` integer DEFAULT 0 NOT NULL,
+	`started_at` text NOT NULL,
+	`finalized_at` text,
+	`last_error` text,
+	CONSTRAINT "activity_epochs_status_check" CHECK("activity_epochs"."status" IN ('syncing', 'finalized', 'failed')),
+	CONSTRAINT "activity_epochs_counts_check" CHECK(("activity_epochs"."expected_elected_count" IS NULL OR "activity_epochs"."expected_elected_count" >= 0)
+      AND ("activity_epochs"."stored_elected_count" IS NULL OR "activity_epochs"."stored_elected_count" >= 0)
+      AND "activity_epochs"."attempt_count" >= 0),
+	CONSTRAINT "activity_epochs_finalized_check" CHECK("activity_epochs"."status" != 'finalized' OR (
+      "activity_epochs"."expected_elected_count" IS NOT NULL
+      AND "activity_epochs"."stored_elected_count" IS NOT NULL
+      AND "activity_epochs"."expected_elected_count" = "activity_epochs"."stored_elected_count"
+      AND "activity_epochs"."elected_set_hash" IS NOT NULL
+      AND length(trim("activity_epochs"."elected_set_hash", ' ' || char(9) || char(10) || char(13))) > 0
+      AND length(trim("activity_epochs"."started_at", ' ' || char(9) || char(10) || char(13))) > 0
+      AND "activity_epochs"."finalized_at" IS NOT NULL
+      AND length(trim("activity_epochs"."finalized_at", ' ' || char(9) || char(10) || char(13))) > 0
+      AND "activity_epochs"."last_error" IS NULL
+    ))
+);
+--> statement-breakpoint
+CREATE INDEX `idx_activity_epochs_status` ON `activity_epochs` (`status`);--> statement-breakpoint
+CREATE INDEX `idx_activity_epochs_finalized` ON `activity_epochs` (`status`,`epoch_number`);--> statement-breakpoint
+PRAGMA foreign_keys=OFF;--> statement-breakpoint
+CREATE TABLE `__new_scores` (
+	`validator_id` integer NOT NULL,
+	`epoch_number` integer NOT NULL,
+	`score_version` integer DEFAULT 1 NOT NULL,
+	`total` real NOT NULL,
+	`availability` real NOT NULL,
+	`recent_availability` real,
+	`long_term_availability` real,
+	`dominance` real NOT NULL,
+	`reliability` real NOT NULL,
+	`data_status` text DEFAULT 'complete' NOT NULL,
+	`long_term_coverage` real,
+	`long_term_as_of_epoch` integer,
+	PRIMARY KEY(`validator_id`, `epoch_number`, `score_version`),
+	FOREIGN KEY (`validator_id`) REFERENCES `validators`(`id`) ON UPDATE no action ON DELETE cascade,
+	CONSTRAINT "scores_version_check" CHECK(score_version IN (1, 2)),
+	CONSTRAINT "scores_data_status_check" CHECK(data_status IN ('complete', 'stale'))
+);
+--> statement-breakpoint
+INSERT INTO `__new_scores`("validator_id", "epoch_number", "score_version", "total", "availability", "recent_availability", "long_term_availability", "dominance", "reliability", "data_status", "long_term_coverage", "long_term_as_of_epoch") SELECT "validator_id", "epoch_number", 1, "total", "availability", NULL, NULL, "dominance", "reliability", 'complete', NULL, NULL FROM `scores`;--> statement-breakpoint
+DROP TABLE `scores`;--> statement-breakpoint
+ALTER TABLE `__new_scores` RENAME TO `scores`;--> statement-breakpoint
+PRAGMA foreign_keys=ON;--> statement-breakpoint
+CREATE INDEX `idx_validator_id` ON `scores` (`validator_id`);--> statement-breakpoint
+CREATE INDEX `idx_scores_validator_version_epoch` ON `scores` (`validator_id`,`score_version`,`epoch_number`);
diff --git a/server/db/migrations/meta/0003_snapshot.json b/server/db/migrations/meta/0003_snapshot.json
new file mode 100644
index 00000000..81d3e922
--- /dev/null
+++ b/server/db/migrations/meta/0003_snapshot.json
@@ -0,0 +1,405 @@
+{
+  "version": "6",
+  "dialect": "sqlite",
+  "id": "f69103c1-cc3d-4133-824b-a0c42f745048",
+  "prevId": "135407bf-b7e3-4fc4-bf99-8f060a77174d",
+  "tables": {
+    "activity": {
+      "name": "activity",
+      "columns": {
+        "validator_id": {
+          "name": "validator_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "epoch_number": {
+          "name": "epoch_number",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "likelihood": {
+          "name": "likelihood",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "rewarded": {
+          "name": "rewarded",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "missed": {
+          "name": "missed",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "dominance_ratio_via_balance": {
+          "name": "dominance_ratio_via_balance",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "dominance_ratio_via_slots": {
+          "name": "dominance_ratio_via_slots",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "balance": {
+          "name": "balance",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": -1
+        },
+        "stakers": {
+          "name": "stakers",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        }
+      },
+      "indexes": {
+        "idx_election_block": {
+          "name": "idx_election_block",
+          "columns": [
+            "epoch_number"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "activity_validator_id_validators_id_fk": {
+          "name": "activity_validator_id_validators_id_fk",
+          "tableFrom": "activity",
+          "tableTo": "validators",
+          "columnsFrom": [
+            "validator_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "activity_validator_id_epoch_number_pk": {
+          "columns": [
+            "validator_id",
+            "epoch_number"
+          ],
+          "name": "activity_validator_id_epoch_number_pk"
+        }
+      },
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "cron_runs": {
+      "name": "cron_runs",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "integer",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": true
+        },
+        "cron": {
+          "name": "cron",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "network": {
+          "name": "network",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "git_branch": {
+          "name": "git_branch",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "started_at": {
+          "name": "started_at",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "finished_at": {
+          "name": "finished_at",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "status": {
+          "name": "status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "error_message": {
+          "name": "error_message",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "meta": {
+          "name": "meta",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "idx_cron_runs_started_at": {
+          "name": "idx_cron_runs_started_at",
+          "columns": [
+            "started_at"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "scores": {
+      "name": "scores",
+      "columns": {
+        "validator_id": {
+          "name": "validator_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "epoch_number": {
+          "name": "epoch_number",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "total": {
+          "name": "total",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "availability": {
+          "name": "availability",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "dominance": {
+          "name": "dominance",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "reliability": {
+          "name": "reliability",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "idx_validator_id": {
+          "name": "idx_validator_id",
+          "columns": [
+            "validator_id"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "scores_validator_id_validators_id_fk": {
+          "name": "scores_validator_id_validators_id_fk",
+          "tableFrom": "scores",
+          "tableTo": "validators",
+          "columnsFrom": [
+            "validator_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "scores_validator_id_epoch_number_pk": {
+          "columns": [
+            "validator_id",
+            "epoch_number"
+          ],
+          "name": "scores_validator_id_epoch_number_pk"
+        }
+      },
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "validators": {
+      "name": "validators",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "integer",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'Unknown validator'"
+        },
+        "address": {
+          "name": "address",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "fee": {
+          "name": "fee",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false,
+          "default": -1
+        },
+        "payout_type": {
+          "name": "payout_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false,
+          "default": "'none'"
+        },
+        "payout_schedule": {
+          "name": "payout_schedule",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "is_maintained_by_nimiq": {
+          "name": "is_maintained_by_nimiq",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false,
+          "default": false
+        },
+        "logo": {
+          "name": "logo",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "has_default_logo": {
+          "name": "has_default_logo",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": true
+        },
+        "accent_color": {
+          "name": "accent_color",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "website": {
+          "name": "website",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "contact": {
+          "name": "contact",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "validators_address_unique": {
+          "name": "validators_address_unique",
+          "columns": [
+            "address"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {
+        "enum_check": {
+          "name": "enum_check",
+          "value": "\"validators\".\"payout_type\" IN ('none', 'restake', 'direct')"
+        }
+      }
+    }
+  },
+  "views": {},
+  "enums": {},
+  "_meta": {
+    "schemas": {},
+    "tables": {},
+    "columns": {}
+  },
+  "internal": {
+    "indexes": {}
+  }
+}
diff --git a/server/db/migrations/meta/0004_snapshot.json b/server/db/migrations/meta/0004_snapshot.json
new file mode 100644
index 00000000..146225c8
--- /dev/null
+++ b/server/db/migrations/meta/0004_snapshot.json
@@ -0,0 +1,412 @@
+{
+  "version": "6",
+  "dialect": "sqlite",
+  "id": "055aefbe-efb9-460f-a4cb-c2af569bbbf9",
+  "prevId": "f69103c1-cc3d-4133-824b-a0c42f745048",
+  "tables": {
+    "activity": {
+      "name": "activity",
+      "columns": {
+        "validator_id": {
+          "name": "validator_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "epoch_number": {
+          "name": "epoch_number",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "likelihood": {
+          "name": "likelihood",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "rewarded": {
+          "name": "rewarded",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "missed": {
+          "name": "missed",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "dominance_ratio_via_balance": {
+          "name": "dominance_ratio_via_balance",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "dominance_ratio_via_slots": {
+          "name": "dominance_ratio_via_slots",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "balance": {
+          "name": "balance",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": -1
+        },
+        "stakers": {
+          "name": "stakers",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        }
+      },
+      "indexes": {
+        "idx_election_block": {
+          "name": "idx_election_block",
+          "columns": [
+            "epoch_number"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "activity_validator_id_validators_id_fk": {
+          "name": "activity_validator_id_validators_id_fk",
+          "tableFrom": "activity",
+          "tableTo": "validators",
+          "columnsFrom": [
+            "validator_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "activity_validator_id_epoch_number_pk": {
+          "columns": [
+            "validator_id",
+            "epoch_number"
+          ],
+          "name": "activity_validator_id_epoch_number_pk"
+        }
+      },
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "cron_runs": {
+      "name": "cron_runs",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "integer",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": true
+        },
+        "cron": {
+          "name": "cron",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "network": {
+          "name": "network",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "git_branch": {
+          "name": "git_branch",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "started_at": {
+          "name": "started_at",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "finished_at": {
+          "name": "finished_at",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "status": {
+          "name": "status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "error_message": {
+          "name": "error_message",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "meta": {
+          "name": "meta",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "idx_cron_runs_started_at": {
+          "name": "idx_cron_runs_started_at",
+          "columns": [
+            "started_at"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "scores": {
+      "name": "scores",
+      "columns": {
+        "validator_id": {
+          "name": "validator_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "epoch_number": {
+          "name": "epoch_number",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "total": {
+          "name": "total",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "availability": {
+          "name": "availability",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "dominance": {
+          "name": "dominance",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "reliability": {
+          "name": "reliability",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "idx_validator_id": {
+          "name": "idx_validator_id",
+          "columns": [
+            "validator_id"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "scores_validator_id_validators_id_fk": {
+          "name": "scores_validator_id_validators_id_fk",
+          "tableFrom": "scores",
+          "tableTo": "validators",
+          "columnsFrom": [
+            "validator_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "scores_validator_id_epoch_number_pk": {
+          "columns": [
+            "validator_id",
+            "epoch_number"
+          ],
+          "name": "scores_validator_id_epoch_number_pk"
+        }
+      },
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "validators": {
+      "name": "validators",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "integer",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'Unknown validator'"
+        },
+        "address": {
+          "name": "address",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "fee": {
+          "name": "fee",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false,
+          "default": -1
+        },
+        "payout_type": {
+          "name": "payout_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false,
+          "default": "'none'"
+        },
+        "payout_schedule": {
+          "name": "payout_schedule",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "is_maintained_by_nimiq": {
+          "name": "is_maintained_by_nimiq",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false,
+          "default": false
+        },
+        "logo": {
+          "name": "logo",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "has_default_logo": {
+          "name": "has_default_logo",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": true
+        },
+        "accent_color": {
+          "name": "accent_color",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "website": {
+          "name": "website",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "contact": {
+          "name": "contact",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "is_listed": {
+          "name": "is_listed",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "validators_address_unique": {
+          "name": "validators_address_unique",
+          "columns": [
+            "address"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {
+        "enum_check": {
+          "name": "enum_check",
+          "value": "\"validators\".\"payout_type\" IN ('none', 'restake', 'direct')"
+        }
+      }
+    }
+  },
+  "views": {},
+  "enums": {},
+  "_meta": {
+    "schemas": {},
+    "tables": {},
+    "columns": {}
+  },
+  "internal": {
+    "indexes": {}
+  }
+}
diff --git a/server/db/migrations/meta/0005_snapshot.json b/server/db/migrations/meta/0005_snapshot.json
new file mode 100644
index 00000000..70d23223
--- /dev/null
+++ b/server/db/migrations/meta/0005_snapshot.json
@@ -0,0 +1,578 @@
+{
+  "version": "6",
+  "dialect": "sqlite",
+  "id": "c17fede6-aa4d-422b-8fdc-d7cdb4c0cc58",
+  "prevId": "055aefbe-efb9-460f-a4cb-c2af569bbbf9",
+  "tables": {
+    "activity": {
+      "name": "activity",
+      "columns": {
+        "validator_id": {
+          "name": "validator_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "epoch_number": {
+          "name": "epoch_number",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "likelihood": {
+          "name": "likelihood",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "rewarded": {
+          "name": "rewarded",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "missed": {
+          "name": "missed",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "dominance_ratio_via_balance": {
+          "name": "dominance_ratio_via_balance",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "dominance_ratio_via_slots": {
+          "name": "dominance_ratio_via_slots",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "balance": {
+          "name": "balance",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": -1
+        },
+        "stakers": {
+          "name": "stakers",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        }
+      },
+      "indexes": {
+        "idx_election_block": {
+          "name": "idx_election_block",
+          "columns": [
+            "epoch_number"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "activity_validator_id_validators_id_fk": {
+          "name": "activity_validator_id_validators_id_fk",
+          "tableFrom": "activity",
+          "tableTo": "validators",
+          "columnsFrom": [
+            "validator_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "activity_validator_id_epoch_number_pk": {
+          "columns": [
+            "validator_id",
+            "epoch_number"
+          ],
+          "name": "activity_validator_id_epoch_number_pk"
+        }
+      },
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "activity_epochs": {
+      "name": "activity_epochs",
+      "columns": {
+        "epoch_number": {
+          "name": "epoch_number",
+          "type": "integer",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "status": {
+          "name": "status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "expected_elected_count": {
+          "name": "expected_elected_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "stored_elected_count": {
+          "name": "stored_elected_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "elected_set_hash": {
+          "name": "elected_set_hash",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "attempt_count": {
+          "name": "attempt_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "started_at": {
+          "name": "started_at",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "finalized_at": {
+          "name": "finalized_at",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "last_error": {
+          "name": "last_error",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "idx_activity_epochs_status": {
+          "name": "idx_activity_epochs_status",
+          "columns": [
+            "status"
+          ],
+          "isUnique": false
+        },
+        "idx_activity_epochs_finalized": {
+          "name": "idx_activity_epochs_finalized",
+          "columns": [
+            "status",
+            "epoch_number"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {
+        "activity_epochs_status_check": {
+          "name": "activity_epochs_status_check",
+          "value": "\"activity_epochs\".\"status\" IN ('syncing', 'finalized', 'failed')"
+        },
+        "activity_epochs_counts_check": {
+          "name": "activity_epochs_counts_check",
+          "value": "(\"activity_epochs\".\"expected_elected_count\" IS NULL OR \"activity_epochs\".\"expected_elected_count\" >= 0)\n      AND (\"activity_epochs\".\"stored_elected_count\" IS NULL OR \"activity_epochs\".\"stored_elected_count\" >= 0)\n      AND \"activity_epochs\".\"attempt_count\" >= 0"
+        },
+        "activity_epochs_finalized_check": {
+          "name": "activity_epochs_finalized_check",
+          "value": "\"activity_epochs\".\"status\" != 'finalized' OR (\n      \"activity_epochs\".\"expected_elected_count\" IS NOT NULL\n      AND \"activity_epochs\".\"stored_elected_count\" IS NOT NULL\n      AND \"activity_epochs\".\"expected_elected_count\" = \"activity_epochs\".\"stored_elected_count\"\n      AND \"activity_epochs\".\"elected_set_hash\" IS NOT NULL\n      AND length(trim(\"activity_epochs\".\"elected_set_hash\", ' ' || char(9) || char(10) || char(13))) > 0\n      AND length(trim(\"activity_epochs\".\"started_at\", ' ' || char(9) || char(10) || char(13))) > 0\n      AND \"activity_epochs\".\"finalized_at\" IS NOT NULL\n      AND length(trim(\"activity_epochs\".\"finalized_at\", ' ' || char(9) || char(10) || char(13))) > 0\n      AND \"activity_epochs\".\"last_error\" IS NULL\n    )"
+        }
+      }
+    },
+    "cron_runs": {
+      "name": "cron_runs",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "integer",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": true
+        },
+        "cron": {
+          "name": "cron",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "network": {
+          "name": "network",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "git_branch": {
+          "name": "git_branch",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "started_at": {
+          "name": "started_at",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "finished_at": {
+          "name": "finished_at",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "status": {
+          "name": "status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "error_message": {
+          "name": "error_message",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "meta": {
+          "name": "meta",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "idx_cron_runs_started_at": {
+          "name": "idx_cron_runs_started_at",
+          "columns": [
+            "started_at"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "scores": {
+      "name": "scores",
+      "columns": {
+        "validator_id": {
+          "name": "validator_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "epoch_number": {
+          "name": "epoch_number",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "score_version": {
+          "name": "score_version",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 1
+        },
+        "total": {
+          "name": "total",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "availability": {
+          "name": "availability",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "recent_availability": {
+          "name": "recent_availability",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "long_term_availability": {
+          "name": "long_term_availability",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "dominance": {
+          "name": "dominance",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "reliability": {
+          "name": "reliability",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "data_status": {
+          "name": "data_status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'complete'"
+        },
+        "long_term_coverage": {
+          "name": "long_term_coverage",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "long_term_as_of_epoch": {
+          "name": "long_term_as_of_epoch",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "idx_validator_id": {
+          "name": "idx_validator_id",
+          "columns": [
+            "validator_id"
+          ],
+          "isUnique": false
+        },
+        "idx_scores_validator_version_epoch": {
+          "name": "idx_scores_validator_version_epoch",
+          "columns": [
+            "validator_id",
+            "score_version",
+            "epoch_number"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "scores_validator_id_validators_id_fk": {
+          "name": "scores_validator_id_validators_id_fk",
+          "tableFrom": "scores",
+          "tableTo": "validators",
+          "columnsFrom": [
+            "validator_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "scores_validator_id_epoch_number_score_version_pk": {
+          "columns": [
+            "validator_id",
+            "epoch_number",
+            "score_version"
+          ],
+          "name": "scores_validator_id_epoch_number_score_version_pk"
+        }
+      },
+      "uniqueConstraints": {},
+      "checkConstraints": {
+        "scores_version_check": {
+          "name": "scores_version_check",
+          "value": "score_version IN (1, 2)"
+        },
+        "scores_data_status_check": {
+          "name": "scores_data_status_check",
+          "value": "data_status IN ('complete', 'stale')"
+        }
+      }
+    },
+    "validators": {
+      "name": "validators",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "integer",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'Unknown validator'"
+        },
+        "address": {
+          "name": "address",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "fee": {
+          "name": "fee",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false,
+          "default": -1
+        },
+        "payout_type": {
+          "name": "payout_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false,
+          "default": "'none'"
+        },
+        "payout_schedule": {
+          "name": "payout_schedule",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "is_maintained_by_nimiq": {
+          "name": "is_maintained_by_nimiq",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false,
+          "default": false
+        },
+        "logo": {
+          "name": "logo",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "has_default_logo": {
+          "name": "has_default_logo",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": true
+        },
+        "accent_color": {
+          "name": "accent_color",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "website": {
+          "name": "website",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "contact": {
+          "name": "contact",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "is_listed": {
+          "name": "is_listed",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "validators_address_unique": {
+          "name": "validators_address_unique",
+          "columns": [
+            "address"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {
+        "enum_check": {
+          "name": "enum_check",
+          "value": "\"validators\".\"payout_type\" IN ('none', 'restake', 'direct')"
+        }
+      }
+    }
+  },
+  "views": {},
+  "enums": {},
+  "_meta": {
+    "schemas": {},
+    "tables": {},
+    "columns": {}
+  },
+  "internal": {
+    "indexes": {}
+  }
+}
diff --git a/server/db/migrations/meta/_journal.json b/server/db/migrations/meta/_journal.json
index ce83b745..40f5bc88 100644
--- a/server/db/migrations/meta/_journal.json
+++ b/server/db/migrations/meta/_journal.json
@@ -22,6 +22,27 @@
       "when": 1746604297839,
       "tag": "0002_magenta_anita_blake",
       "breakpoints": true
+    },
+    {
+      "idx": 3,
+      "version": "6",
+      "when": 1770359882000,
+      "tag": "0003_add_cron_runs",
+      "breakpoints": true
+    },
+    {
+      "idx": 4,
+      "version": "6",
+      "when": 1772449289000,
+      "tag": "0004_add_validator_is_listed",
+      "breakpoints": true
+    },
+    {
+      "idx": 5,
+      "version": "6",
+      "when": 1785251589431,
+      "tag": "0005_validator_activity_integrity_score_v2",
+      "breakpoints": true
     }
   ]
 }
diff --git a/server/db/migrations/migrations.integration.test.ts b/server/db/migrations/migrations.integration.test.ts
new file mode 100644
index 00000000..6149e8ab
--- /dev/null
+++ b/server/db/migrations/migrations.integration.test.ts
@@ -0,0 +1,126 @@
+import type { Client } from '@libsql/client'
+import { readFile } from 'node:fs/promises'
+import { fileURLToPath } from 'node:url'
+import { createClient } from '@libsql/client'
+import { afterEach, describe, expect, it } from 'vitest'
+
+const migrationDirectory = fileURLToPath(new URL('.', import.meta.url))
+const clients: Client[] = []
+
+async function executeMigration(
+  client: Client,
+  filename: string,
+) {
+  const migration = await readFile(`${migrationDirectory}${filename}`, 'utf8')
+  await client.executeMultiple(migration)
+}
+
+describe('database migrations', () => {
+  afterEach(() => {
+    for (const client of clients)
+      client.close()
+    clients.length = 0
+  })
+
+  it('migrates pre-0005 scores and keeps score checks valid after the table rename', async () => {
+    const client = createClient({ url: 'file::memory:' })
+    clients.push(client)
+    await client.execute('PRAGMA legacy_alter_table = ON')
+
+    for (const migration of [
+      '0000_cultured_wallflower.sql',
+      '0001_dashing_whiplash.sql',
+      '0002_magenta_anita_blake.sql',
+      '0003_add_cron_runs.sql',
+      '0004_add_validator_is_listed.sql',
+    ]) {
+      await executeMigration(client, migration)
+    }
+
+    await client.execute('ALTER TABLE validators ADD COLUMN is_listed integer')
+    await client.execute(`
+      INSERT INTO validators (
+        id,
+        address,
+        logo,
+        accent_color,
+        is_listed
+      ) VALUES (1, 'NQ00 TEST', 'logo.svg', '#fff', 1)
+    `)
+    await client.execute(`
+      INSERT INTO scores (
+        validator_id,
+        epoch_number,
+        total,
+        availability,
+        dominance,
+        reliability
+      ) VALUES (1, 100, 0.8, 0.9, 0.7, 0.6)
+    `)
+
+    await executeMigration(client, '0005_validator_activity_integrity_score_v2.sql')
+
+    const migrated = await client.execute(`
+      SELECT
+        score_version,
+        data_status,
+        recent_availability,
+        long_term_availability,
+        long_term_coverage,
+        long_term_as_of_epoch
+      FROM scores
+      WHERE validator_id = 1 AND epoch_number = 100
+    `)
+    expect(migrated.rows).toEqual([{
+      score_version: 1,
+      data_status: 'complete',
+      recent_availability: null,
+      long_term_availability: null,
+      long_term_coverage: null,
+      long_term_as_of_epoch: null,
+    }])
+
+    await client.execute(`
+      INSERT INTO scores (
+        validator_id,
+        epoch_number,
+        score_version,
+        total,
+        availability,
+        recent_availability,
+        long_term_availability,
+        dominance,
+        reliability,
+        data_status,
+        long_term_coverage,
+        long_term_as_of_epoch
+      ) VALUES (1, 101, 2, 0.9, 0.91, 0.92, 0.89, 0.8, 0.7, 'stale', 0.95, 99)
+    `)
+
+    await expect(client.execute(`
+      INSERT INTO scores (
+        validator_id,
+        epoch_number,
+        score_version,
+        total,
+        availability,
+        dominance,
+        reliability,
+        data_status
+      ) VALUES (1, 102, 3, 0.9, 0.91, 0.8, 0.7, 'complete')
+    `)).rejects.toThrow()
+
+    await expect(client.execute(`
+      INSERT INTO scores (
+        validator_id,
+        epoch_number,
+        score_version,
+        total,
+        availability,
+        dominance,
+        reliability,
+        data_status
+      ) VALUES (1, 102, 2, 0.9, 0.91, 0.8, 0.7, 'invalid')
+    `)).rejects.toThrow()
+  })
+})
diff --git a/server/db/schema.ts b/server/db/schema.ts
index 4edc4bae..92ecaae9 100644
--- a/server/db/schema.ts
+++ b/server/db/schema.ts
@@ -2,6 +2,15 @@ import { relations, sql } from 'drizzle-orm'
 import { check, index, integer, primaryKey, real, sqliteTable, text, uniqueIndex } from 'drizzle-orm/sqlite-core'
 import { PayoutType } from '../utils/types'
 
+export const ActivityEpochStatus = {
+  Syncing: 'syncing',
+  Finalized: 'finalized',
+  Failed: 'failed',
+} as const
+
+export type ScoreVersion = 1 | 2
+export type ScoreDataStatus = 'complete' | 'stale'
+
 export const validators = sqliteTable('validators', {
   id: integer('id').primaryKey({ autoIncrement: true, onConflict: 'replace' }),
   name: text('name').default('Unknown validator').notNull(),
@@ -29,13 +38,22 @@ export const validators = sqliteTable('validators', {
 export const scores = sqliteTable('scores', {
   validatorId: integer('validator_id').notNull().references(() => validators.id, { onDelete: 'cascade' }),
   epochNumber: integer('epoch_number').notNull(),
+  scoreVersion: integer('score_version').$type<ScoreVersion>().notNull().default(1),
   total: real('total').notNull(),
   availability: real('availability').notNull(),
+  recentAvailability: real('recent_availability'),
+  longTermAvailability: real('long_term_availability'),
   dominance: real('dominance').notNull(),
   reliability: real('reliability').notNull(),
+  dataStatus: text('data_status').$type<ScoreDataStatus>().notNull().default('complete'),
+  longTermCoverage: real('long_term_coverage'),
+  longTermAsOfEpoch: integer('long_term_as_of_epoch'),
 }, table => [
   index('idx_validator_id').on(table.validatorId),
-  primaryKey({ columns: [table.validatorId, table.epochNumber] }),
+  index('idx_scores_validator_version_epoch').on(table.validatorId, table.scoreVersion, table.epochNumber),
+  primaryKey({ columns: [table.validatorId, table.epochNumber, table.scoreVersion] }),
+  check('scores_version_check', sql.raw('score_version IN (1, 2)')),
+  check('scores_data_status_check', sql.raw('data_status IN (\'complete\', \'stale\')')),
 ])
 
 export const scoresRelations = relations(scores, ({ one }) => ({
@@ -60,6 +78,47 @@ export const activity = sqliteTable('activity', {
   primaryKey({ columns: [table.validatorId, table.epochNumber] }),
 ])
 
+export const activityEpochs = sqliteTable('activity_epochs', {
+  epochNumber: integer('epoch_number').primaryKey(),
+  status: text('status', {
+    enum: [ActivityEpochStatus.Syncing, ActivityEpochStatus.Finalized, ActivityEpochStatus.Failed],
+  }).notNull(),
+  expectedElectedCount: integer('expected_elected_count'),
+  storedElectedCount: integer('stored_elected_count'),
+  electedSetHash: text('elected_set_hash'),
+  attemptCount: integer('attempt_count').notNull().default(0),
+  startedAt: text('started_at').notNull(),
+  finalizedAt: text('finalized_at'),
+  lastError: text('last_error'),
+}, table => [
+  index('idx_activity_epochs_status').on(table.status),
+  index('idx_activity_epochs_finalized').on(table.status, table.epochNumber),
+  check(
+    'activity_epochs_status_check',
+    sql`${table.status} IN ('syncing', 'finalized', 'failed')`,
+  ),
+  check(
+    'activity_epochs_counts_check',
+    sql`(${table.expectedElectedCount} IS NULL OR ${table.expectedElectedCount} >= 0)
+      AND (${table.storedElectedCount} IS NULL OR ${table.storedElectedCount} >= 0)
+      AND ${table.attemptCount} >= 0`,
+  ),
+  check(
+    'activity_epochs_finalized_check',
+    sql`${table.status} != 'finalized' OR (
+      ${table.expectedElectedCount} IS NOT NULL
+      AND ${table.storedElectedCount} IS NOT NULL
+      AND ${table.expectedElectedCount} = ${table.storedElectedCount}
+      AND ${table.electedSetHash} IS NOT NULL
+      AND length(trim(${table.electedSetHash}, ' ' || char(9) || char(10) || char(13))) > 0
+      AND length(trim(${table.startedAt}, ' ' || char(9) || char(10) || char(13))) > 0
+      AND ${table.finalizedAt} IS NOT NULL
+      AND length(trim(${table.finalizedAt}, ' ' || char(9) || char(10) || char(13))) > 0
+      AND ${table.lastError} IS NULL
+    )`,
+  ),
+])
+
 export const cronRuns = sqliteTable('cron_runs', {
   id: integer('id').primaryKey({ autoIncrement: true }),
   cron: text('cron').notNull(),
diff --git a/server/tasks/cron/sync.test.ts b/server/tasks/cron/sync.test.ts
new file mode 100644
index 00000000..3757945e
--- /dev/null
+++ b/server/tasks/cron/sync.test.ts
@@ -0,0 +1,114 @@
+import { afterAll, beforeEach, describe, expect, it, vi } from 'vitest'
+
+const mocks = vi.hoisted(() => ({
+  runTask: vi.fn(),
+  insertValues: vi.fn(),
+  insertGet: vi.fn(),
+  updateSet: vi.fn(),
+  updateExecute: vi.fn(),
+}))
+
+vi.mock('nitropack/runtime', () => ({
+  runTask: mocks.runTask,
+}))
+
+vi.mock('../../utils/drizzle', () => ({
+  eq: vi.fn(() => ({ kind: 'eq' })),
+  tables: {
+    cronRuns: {
+      id: 'id',
+    },
+  },
+  useDrizzle: () => ({
+    insert: () => ({
+      values: (values: unknown) => {
+        mocks.insertValues(values)
+        return {
+          returning: () => ({
+            get: mocks.insertGet,
+          }),
+        }
+      },
+    }),
+    update: () => ({
+      set: (values: unknown) => {
+        mocks.updateSet(values)
+        return {
+          where: () => ({
+            execute: mocks.updateExecute,
+          }),
+        }
+      },
+    }),
+  }),
+}))
+
+vi.stubGlobal('defineTask', (task: unknown) => task)
+vi.stubGlobal('useSafeRuntimeConfig', () => ({
+  public: {
+    nimiqNetwork: 'testnet',
+    gitBranch: 'test',
+  },
+}))
+
+type CronSyncTask = typeof import('./sync')['default']
+let task: CronSyncTask
+
+beforeEach(async () => {
+  vi.resetAllMocks()
+  mocks.insertGet.mockResolvedValue({ id: 1 })
+  mocks.updateExecute.mockResolvedValue(undefined)
+  mocks.runTask.mockResolvedValue({ result: { success: true } })
+
+  vi.resetModules()
+  task = (await import('./sync')).default
+})
+
+afterAll(() => {
+  vi.unstubAllGlobals()
+})
+
+describe('scheduled synchronization order', () => {
+  it('records the six-hour schedule', async () => {
+    await task.run({ payload: {}, context: {} } as never)
+
+    expect(mocks.insertValues).toHaveBeenCalledWith(expect.objectContaining({
+      cron: '0 */6 * * *',
+    }))
+  })
+
+  it('runs the independent score task after snapshot synchronization', async () => {
+    await task.run({ payload: {}, context: {} } as never)
+
+    expect(mocks.runTask.mock.calls.map(([taskName]) => taskName)).toEqual([
+      'sync:epochs',
+      'sync:snapshot',
+      'sync:scores',
+    ])
+  })
+
+  it('runs all tasks before recording and rejecting aggregate failures', async () => {
+    mocks.runTask
+      .mockResolvedValueOnce({ result: { success: false, error: 'epochs failed' } })
+      .mockRejectedValueOnce(new Error('snapshot failed'))
+      .mockResolvedValueOnce({ result: { success: true } })
+
+    await expect(task.run({ payload: {}, context: {} } as never)).rejects.toThrow(/task failures/i)
+
+    expect(mocks.runTask.mock.calls.map(([taskName]) => taskName)).toEqual([
+      'sync:epochs',
+      'sync:snapshot',
+      'sync:scores',
+    ])
+    expect(mocks.updateSet).toHaveBeenCalledWith(expect.objectContaining({
+      status: 'error',
+      meta: expect.objectContaining({
+        failedTasks: [
+          expect.objectContaining({ name: 'sync:epochs', error: 'epochs failed' }),
+          expect.objectContaining({ name: 'sync:snapshot', error: 'snapshot failed' }),
+        ],
+      }),
+    }))
+    expect(mocks.updateExecute).toHaveBeenCalledTimes(1)
+  })
+})
diff --git a/server/tasks/cron/sync.ts b/server/tasks/cron/sync.ts
index db2a5803..bc302265 100644
--- a/server/tasks/cron/sync.ts
+++ b/server/tasks/cron/sync.ts
@@ -1,10 +1,11 @@
 import type { TaskEvent } from 'nitropack'
 import { consola } from 'consola'
 import { runTask } from 'nitropack/runtime'
+import { runTasksBestEffort } from '~~/server/utils/cron-task-runner'
 import { eq, tables, useDrizzle } from '~~/server/utils/drizzle'
 
-const CRON_EXPRESSION = '0 */12 * * *'
-const TASKS: string[] = ['sync:epochs', 'sync:snapshot']
+const CRON_EXPRESSION = '0 */6 * * *'
+const TASKS: string[] = ['sync:epochs', 'sync:snapshot', 'sync:scores']
 
 interface FailedTask {
   name: string
@@ -64,20 +65,19 @@ export default defineTask({
     }
 
     try {
-      const results: Record<string, unknown> = {}
-
-      for (const taskName of TASKS) {
+      const executions = await runTasksBestEffort(TASKS, async (taskName) => {
         consola.info(`[cron:sync] running ${taskName}`)
-        const res = await runTask(taskName, { payload: event.payload ?? {}, context: event.context ?? {} })
-        const result = (res as any)?.result ?? res
-        results[taskName] = result
-        if (result?.success === false)
-          throw new Error(`${taskName} failed: ${result.error || 'unknown'}`)
-      }
-
-      const failedTasks = Object.entries(results)
-        .filter(([, r]) => (r as any)?.success === false)
-        .map(([name, r]) => ({ name, error: (r as any)?.error ?? 'Unknown task failure' }))
+        return runTask(taskName, { payload: event.payload ?? {}, context: event.context ?? {} })
+      })
+      const results = Object.fromEntries(executions.map(execution => [
+        execution.name,
+        execution.success
+          ? ((execution.value as any)?.result ?? execution.value)
+          : { success: false, error: execution.error },
+      ]))
+      const failedTasks = executions
+        .filter(execution => !execution.success)
+        .map(execution => ({ name: execution.name, error: execution.error || 'Unknown task failure' }))
       if (failedTasks.length > 0)
         throw new CronTaskFailureError(`Task failures: ${JSON.stringify(failedTasks)}`, failedTasks, results)
 
diff --git a/server/tasks/sync/epochs.test.ts b/server/tasks/sync/epochs.test.ts
new file mode 100644
index 00000000..fcb7f00e
--- /dev/null
+++ b/server/tasks/sync/epochs.test.ts
@@ -0,0 +1,166 @@
+import { afterAll, beforeEach, describe, expect, it, vi } from 'vitest'
+
+const mocks = vi.hoisted(() => ({
+  initRpcClient: vi.fn(),
+  fetchElectionSet: vi.fn(),
+  fetchActivity: vi.fn(),
+  getRange: vi.fn(),
+  getRpcUrl: vi.fn(),
+  storeActivities: vi.fn(),
+  findMissingEpochs: vi.fn(),
+  getActivityEpochMarkers: vi.fn(),
+  getRecentEpochRange: vi.fn(),
+  planEpochSync: vi.fn(),
+  synchronizeCompletedEpoch: vi.fn(),
+  sendNewEpochNotification: vi.fn(),
+  sendSyncFailureNotification: vi.fn(),
+  consolaInfo: vi.fn(),
+}))
+
+vi.mock('consola', () => ({
+  consola: { info: mocks.consolaInfo },
+}))
+
+vi.mock('nimiq-rpc-client-ts/client', () => ({
+  initRpcClient: mocks.initRpcClient,
+}))
+
+vi.mock('../../../packages/nimiq-validator-trustscore/src/range', () => ({
+  getRange: mocks.getRange,
+}))
+
+vi.mock('../../../packages/nimiq-validator-trustscore/src/fetcher', () => ({
+  fetchElectionSet: mocks.fetchElectionSet,
+  fetchActivity: mocks.fetchActivity,
+}))
+
+vi.mock('../../../packages/nimiq-validator-trustscore/src/sync-progress', () => ({
+  formatActivityBatchProgress: () => 'activity progress',
+  formatEpochSyncProgress: () => 'epoch progress',
+}))
+
+vi.mock('../../utils/activities', () => ({
+  storeActivities: mocks.storeActivities,
+}))
+
+vi.mock('../../utils/activity-epochs', () => ({
+  DEFAULT_SYNCING_LEASE_DURATION_MS: 6 * 60 * 60 * 1000,
+  getActivityEpochMarkers: mocks.getActivityEpochMarkers,
+  getRecentEpochRange: mocks.getRecentEpochRange,
+  planEpochSync: mocks.planEpochSync,
+}))
+
+vi.mock('../../utils/activity-sync', () => ({
+  synchronizeCompletedEpoch: mocks.synchronizeCompletedEpoch,
+}))
+
+vi.mock('../../utils/rpc', () => ({
+  getRpcUrl: mocks.getRpcUrl,
+}))
+
+vi.mock('../../utils/slack', () => ({
+  sendNewEpochNotification: mocks.sendNewEpochNotification,
+  sendSyncFailureNotification: mocks.sendSyncFailureNotification,
+}))
+
+vi.stubGlobal('defineTask', (task: unknown) => task)
+vi.stubGlobal('useSafeRuntimeConfig', () => ({ public: { nimiqNetwork: 'testnet' } }))
+vi.stubGlobal('findMissingEpochs', mocks.findMissingEpochs)
+
+type EpochSyncTask = typeof import('./epochs')['default']
+let task: EpochSyncTask
+let getEpochCandidateLimit: typeof import('./epochs')['getEpochCandidateLimit']
+let getSyncingLeaseDurationMs: typeof import('./epochs')['getSyncingLeaseDurationMs']
+let isFullRepairAllowed: typeof import('./epochs')['isFullRepairAllowed']
+
+beforeEach(async () => {
+  vi.resetAllMocks()
+  mocks.getRpcUrl.mockReturnValue('http://rpc.test')
+  mocks.findMissingEpochs.mockResolvedValue([])
+  mocks.getRange.mockResolvedValue([true, undefined, {
+    fromEpoch: 1,
+    toEpoch: 100,
+    epochDurationMs: 12 * 60 * 60 * 1000,
+  }])
+  mocks.getActivityEpochMarkers.mockResolvedValue([
+    { epochNumber: 100, status: 'failed', startedAt: '2026-07-28T10:00:00.000Z' },
+    { epochNumber: 99, status: 'failed', startedAt: '2026-07-28T09:00:00.000Z' },
+    { epochNumber: 98, status: 'syncing', startedAt: '2026-07-28T01:00:00.000Z' },
+  ])
+  mocks.getRecentEpochRange.mockReturnValue({ fromEpoch: 73, toEpoch: 100 })
+  mocks.planEpochSync.mockReturnValue([100, 99, 98, 97, 96])
+  mocks.synchronizeCompletedEpoch
+    .mockResolvedValueOnce({ epochNumber: 100, status: 'failed', error: 'first RPC failure', repairAttempted: true })
+    .mockResolvedValueOnce({ epochNumber: 99, status: 'verified' })
+    .mockResolvedValueOnce({ epochNumber: 98, status: 'failed', error: 'repair budget exhausted', repairAttempted: false })
+    .mockResolvedValueOnce({ epochNumber: 97, status: 'verified' })
+    .mockResolvedValueOnce({ epochNumber: 96, status: 'already_finalized' })
+  mocks.sendSyncFailureNotification.mockResolvedValue(undefined)
+
+  vi.resetModules()
+  const epochsModule = await import('./epochs')
+  task = epochsModule.default
+  getEpochCandidateLimit = epochsModule.getEpochCandidateLimit
+  getSyncingLeaseDurationMs = epochsModule.getSyncingLeaseDurationMs
+  isFullRepairAllowed = epochsModule.isFullRepairAllowed
+})
+
+afterAll(() => {
+  vi.unstubAllGlobals()
+})
+
+describe('planned completed-epoch synchronization', () => {
+  it('processes every candidate and repair in development while keeping production bounded', () => {
+    expect(getEpochCandidateLimit(true)).toBe(Infinity)
+    expect(getEpochCandidateLimit(false)).toBe(50)
+    expect(getSyncingLeaseDurationMs(true)).toBe(5 * 60 * 1000)
+    expect(getSyncingLeaseDurationMs(false)).toBe(6 * 60 * 60 * 1000)
+    expect(isFullRepairAllowed(0, true)).toBe(true)
+    expect(isFullRepairAllowed(5, true)).toBe(true)
+    expect(isFullRepairAllowed(0, false)).toBe(true)
+    expect(isFullRepairAllowed(1, false)).toBe(false)
+  })
+
+  it('limits production repairs while returning the failed epoch details', async () => {
+    const result = await task.run()
+
+    expect(mocks.getActivityEpochMarkers).toHaveBeenCalledTimes(1)
+    expect(mocks.getRecentEpochRange).toHaveBeenCalledWith(expect.objectContaining({
+      fromEpoch: 1,
+      toEpoch: 100,
+    }))
+    expect(mocks.planEpochSync).toHaveBeenCalledWith(expect.objectContaining({
+      range: { fromEpoch: 1, toEpoch: 100 },
+      recentRange: { fromEpoch: 73, toEpoch: 100 },
+      markers: [
+        { epochNumber: 100, status: 'failed', startedAt: '2026-07-28T10:00:00.000Z' },
+        { epochNumber: 99, status: 'failed', startedAt: '2026-07-28T09:00:00.000Z' },
+        { epochNumber: 98, status: 'syncing', startedAt: '2026-07-28T01:00:00.000Z' },
+      ],
+      limit: 50,
+      syncingLeaseDurationMs: 6 * 60 * 60 * 1000,
+    }))
+    expect(mocks.synchronizeCompletedEpoch).toHaveBeenNthCalledWith(1, 100, 'testnet', { allowRepair: true })
+    expect(mocks.synchronizeCompletedEpoch).toHaveBeenNthCalledWith(2, 99, 'testnet', { allowRepair: false })
+    expect(mocks.synchronizeCompletedEpoch).toHaveBeenNthCalledWith(3, 98, 'testnet', { allowRepair: false })
+    expect(mocks.synchronizeCompletedEpoch).toHaveBeenNthCalledWith(4, 97, 'testnet', { allowRepair: false })
+    expect(mocks.synchronizeCompletedEpoch).toHaveBeenNthCalledWith(5, 96, 'testnet', { allowRepair: false })
+    expect(mocks.synchronizeCompletedEpoch).toHaveBeenCalledTimes(5)
+
+    expect(result).toEqual({
+      result: {
+        success: false,
+        error: '[sync:epochs] epoch 100 failed: first RPC failure',
+        totalSynced: 2,
+        epochsSynced: [99, 97],
+        outcomes: [
+          { epochNumber: 100, status: 'failed', error: 'first RPC failure', repairAttempted: true },
+          { epochNumber: 99, status: 'verified' },
+          { epochNumber: 98, status: 'failed', error: 'repair budget exhausted', repairAttempted: false },
+          { epochNumber: 97, status: 'verified' },
+          { epochNumber: 96, status: 'already_finalized' },
+        ],
+      },
+    })
+  })
+})
diff --git a/server/tasks/sync/epochs.ts b/server/tasks/sync/epochs.ts
index 2c0081fa..6f173159 100644
--- a/server/tasks/sync/epochs.ts
+++ b/server/tasks/sync/epochs.ts
@@ -1,20 +1,60 @@
+import type { EpochSyncOutcome } from '~~/server/utils/activity-sync'
 import { consola } from 'consola'
 import { initRpcClient } from 'nimiq-rpc-client-ts/client'
-import { fetchActivity } from '~~/packages/nimiq-validator-trustscore/src/fetcher'
 import { getRange } from '~~/packages/nimiq-validator-trustscore/src/range'
-import { formatActivityBatchProgress, formatEpochSyncProgress } from '~~/packages/nimiq-validator-trustscore/src/sync-progress'
-import { storeActivities } from '~~/server/utils/activities'
+import {
+  DEFAULT_SYNCING_LEASE_DURATION_MS,
+  getActivityEpochMarkers,
+  getRecentEpochRange,
+  planEpochSync,
+} from '~~/server/utils/activity-epochs'
+import { synchronizeCompletedEpoch } from '~~/server/utils/activity-sync'
 import { getRpcUrl } from '~~/server/utils/rpc'
-import { sendNewEpochNotification, sendSyncFailureNotification } from '~~/server/utils/slack'
+import { sendSyncFailureNotification } from '~~/server/utils/slack'
 
-// In production, limit epochs per run to avoid Cloudflare Workers 30s CPU timeout.
-// In local dev, no limit so we can sync everything at once.
-const MAX_EPOCHS_PER_RUN = import.meta.dev ? Infinity : 50
+const MAX_PRODUCTION_EPOCH_CANDIDATES_PER_RUN = 50
+const DEVELOPMENT_SYNCING_LEASE_DURATION_MS = 5 * 60 * 1000
+
+export function getEpochCandidateLimit(isDevelopment: boolean): number {
+  return isDevelopment ? Infinity : MAX_PRODUCTION_EPOCH_CANDIDATES_PER_RUN
+}
+
+export function getSyncingLeaseDurationMs(isDevelopment: boolean): number {
+  return isDevelopment
+    ? DEVELOPMENT_SYNCING_LEASE_DURATION_MS
+    : DEFAULT_SYNCING_LEASE_DURATION_MS
+}
+
+export function isFullRepairAllowed(fullRepairAttempts: number, isDevelopment: boolean): boolean {
+  return isDevelopment || fullRepairAttempts === 0
+}
+
+function formatError(error: unknown): string {
+  if (error instanceof Error)
+    return error.message || error.name
+  if (typeof error === 'string')
+    return error
+  try {
+    return JSON.stringify(error) || String(error)
+  }
+  catch {
+    return String(error)
+  }
+}
+
+async function notifyFailure(error: Error) {
+  try {
+    await sendSyncFailureNotification('missing-epoch', error)
+  }
+  catch (notificationError) {
+    consola.info(`[sync:epochs] failure notification failed: ${formatError(notificationError)}`)
+  }
+}
 
 export default defineTask({
   meta: {
     name: 'sync:epochs',
-    description: 'Sync all missing blockchain epochs to D1 database',
+    description: 'Verify and repair completed blockchain epochs',
   },
   async run() {
     const config = useSafeRuntimeConfig()
@@ -28,54 +68,71 @@ export default defineTask({
       const [rangeOk, rangeError, range] = await getRange({ network: config.public.nimiqNetwork })
       if (!rangeOk || !range) {
         const error = new Error(rangeError || 'Unable to fetch range')
-        await sendSyncFailureNotification('missing-epoch', error)
+        await notifyFailure(error)
         return { result: { success: false, error: rangeError } }
       }
 
-      let totalSynced = 0
+      const plannerRange = { fromEpoch: range.fromEpoch, toEpoch: range.toEpoch }
+      const markers = await getActivityEpochMarkers(plannerRange)
+      const recentRange = getRecentEpochRange(range)
+      const plannedEpochs = planEpochSync({
+        range: plannerRange,
+        recentRange,
+        markers,
+        now: new Date(),
+        limit: getEpochCandidateLimit(import.meta.dev),
+        syncingLeaseDurationMs: getSyncingLeaseDurationMs(import.meta.dev),
+      })
+      const outcomes: EpochSyncOutcome[] = []
       const epochsSynced: number[] = []
-      const maxEpochsPerRunLabel = Number.isFinite(MAX_EPOCHS_PER_RUN) ? MAX_EPOCHS_PER_RUN : 'all'
-      consola.info(`[sync:epochs] range ${range.fromEpoch}-${range.toEpoch} on ${config.public.nimiqNetwork}`)
+      let fullRepairAttempts = 0
 
-      while (totalSynced < MAX_EPOCHS_PER_RUN) {
-        const missingEpochs = await findMissingEpochs(range)
-        if (!missingEpochs || missingEpochs.length === 0) {
-          consola.info(`[sync:epochs] no missing epochs after syncing ${totalSynced}`)
-          break
+      for (const epochNumber of plannedEpochs) {
+        let outcome: EpochSyncOutcome
+        try {
+          outcome = await synchronizeCompletedEpoch(epochNumber, config.public.nimiqNetwork, {
+            allowRepair: isFullRepairAllowed(fullRepairAttempts, import.meta.dev),
+          })
         }
-
-        const missingEpoch = missingEpochs.at(0)!
-        consola.info(formatEpochSyncProgress({
-          epochIndex: missingEpoch,
-          missingEpochsCount: missingEpochs.length,
-          runIndex: totalSynced + 1,
-          maxEpochsPerRun: maxEpochsPerRunLabel,
-        }))
-        const [activityOk, activityError, epochActivity] = await fetchActivity(missingEpoch, {
-          network: config.public.nimiqNetwork,
-          maxBatchSize: import.meta.dev ? 120 : 6,
-          onProgress: progress => consola.info(formatActivityBatchProgress(progress)),
-        })
-        if (!activityOk || !epochActivity) {
-          const error = new Error(activityError || 'Unable to fetch activity')
-          await sendSyncFailureNotification('missing-epoch', error)
-          return { result: { success: false, error: activityError, totalSynced, epochsSynced } }
+        catch (error) {
+          outcome = { epochNumber, status: 'failed', error: formatError(error), repairAttempted: false }
         }
+        outcomes.push(outcome)
 
-        await storeActivities({ [`${missingEpoch}`]: epochActivity }, { finalizeEpoch: true })
-        consola.info(`[sync:epochs] epoch ${missingEpoch} stored (${totalSynced + 1}/${maxEpochsPerRunLabel})`)
-        await sendNewEpochNotification(missingEpoch, missingEpochs.length)
+        if (outcome.status === 'verified' || outcome.status === 'repaired')
+          epochsSynced.push(epochNumber)
+        if (outcome.status === 'repaired' || (outcome.status === 'failed' && outcome.repairAttempted))
+          fullRepairAttempts++
+      }
 
-        epochsSynced.push(missingEpoch)
-        totalSynced++
+      const failures = outcomes.filter((outcome): outcome is Extract<EpochSyncOutcome, { status: 'failed' }> => outcome.status === 'failed')
+      const recentFailure = failures.find(outcome => outcome.epochNumber >= recentRange.fromEpoch)
+      const historicalFailures = failures.filter(outcome => outcome.epochNumber < recentRange.fromEpoch)
+      const failureSummaries: string[] = []
+      if (recentFailure) {
+        const summary = `[sync:epochs] epoch ${recentFailure.epochNumber} failed: ${recentFailure.error}`
+        failureSummaries.push(summary)
+        await notifyFailure(new Error(summary))
+      }
+      if (historicalFailures.length > 0) {
+        const summary = `[sync:epochs] ${historicalFailures.length} historical epoch sync failure(s): ${historicalFailures.map(outcome => outcome.epochNumber).join(', ')}`
+        failureSummaries.push(summary)
+        await notifyFailure(new Error(summary))
       }
 
-      consola.info(`[sync:epochs] finished; synced ${totalSynced} epoch(s)`)
-      return { result: { success: true, totalSynced, epochsSynced } }
+      return {
+        result: {
+          success: failures.length === 0,
+          ...(failureSummaries.length > 0 ? { error: failureSummaries.join('; ') } : {}),
+          totalSynced: epochsSynced.length,
+          epochsSynced,
+          outcomes,
+        },
+      }
     }
     catch (error) {
-      await sendSyncFailureNotification('missing-epoch', error)
-      return { result: { success: false, error: String(error) } }
+      await notifyFailure(error instanceof Error ? error : new Error(formatError(error)))
+      return { result: { success: false, error: formatError(error) } }
     }
   },
 })
diff --git a/server/tasks/sync/scores.test.ts b/server/tasks/sync/scores.test.ts
new file mode 100644
index 00000000..2b122228
--- /dev/null
+++ b/server/tasks/sync/scores.test.ts
@@ -0,0 +1,114 @@
+import { afterAll, beforeEach, describe, expect, it, vi } from 'vitest'
+
+const mocks = vi.hoisted(() => ({
+  error: vi.fn(),
+  info: vi.fn(),
+  upsertScoresSnapshotEpoch: vi.fn(),
+  sendSyncFailureNotification: vi.fn(),
+}))
+
+vi.mock('consola', () => ({
+  consola: {
+    error: mocks.error,
+    info: mocks.info,
+  },
+}))
+
+vi.mock('../../utils/scores', () => ({
+  upsertScoresSnapshotEpoch: mocks.upsertScoresSnapshotEpoch,
+}))
+
+vi.mock('../../utils/slack', () => ({
+  sendSyncFailureNotification: mocks.sendSyncFailureNotification,
+}))
+
+vi.stubGlobal('defineTask', (task: unknown) => task)
+vi.stubGlobal('upsertScoresSnapshotEpoch', mocks.upsertScoresSnapshotEpoch)
+
+interface ScoresSyncTask {
+  meta: {
+    name: string
+    description: string
+  }
+  run: () => Promise<unknown>
+}
+
+let task: ScoresSyncTask
+
+beforeEach(async () => {
+  vi.resetAllMocks()
+  mocks.upsertScoresSnapshotEpoch.mockResolvedValue([true, undefined, {
+    dataStatus: 'stale',
+    missingEpochs: [101],
+    scores: [],
+    scoreCounts: { v1: 0, v2: 0 },
+    recentCoverage: 0.5,
+    longTermCoverage: 0.75,
+    backfilledEpochs: [],
+  }])
+  mocks.sendSyncFailureNotification.mockResolvedValue(undefined)
+
+  vi.resetModules()
+  task = (await import('./scores')).default as ScoresSyncTask
+})
+
+afterAll(() => {
+  vi.unstubAllGlobals()
+})
+
+describe('independent score synchronization', () => {
+  it('registers a dedicated sync:scores task', () => {
+    expect(task.meta).toMatchObject({ name: 'sync:scores' })
+  })
+
+  it('reports incomplete marker coverage as a successful stale skip', async () => {
+    await expect(task.run()).resolves.toEqual({
+      result: {
+        success: true,
+        dataStatus: 'stale',
+        missingEpochs: [101],
+        scoreCounts: { v1: 0, v2: 0 },
+        recentCoverage: 0.5,
+        longTermCoverage: 0.75,
+        backfilledEpochs: [],
+      },
+    })
+    expect(mocks.sendSyncFailureNotification).not.toHaveBeenCalled()
+  })
+
+  it('reports per-version counts, coverage, and backfilled epochs for a current snapshot', async () => {
+    mocks.upsertScoresSnapshotEpoch.mockImplementation(async (options) => {
+      options?.onProgress('backfill epoch 119 (1/2): calculating 3 validator(s)')
+      return [true, undefined, {
+        range: { toEpoch: 120 },
+        dataStatus: 'complete',
+        missingEpochs: [],
+        scores: [],
+        scoreCounts: { v1: 3, v2: 2 },
+        recentCoverage: 1,
+        longTermCoverage: 0.8,
+        backfilledEpochs: [119, 118],
+      }]
+    })
+
+    await expect(task.run()).resolves.toEqual({
+      result: {
+        success: true,
+        dataStatus: 'complete',
+        epochNumber: 120,
+        scoreCounts: { v1: 3, v2: 2 },
+        recentCoverage: 1,
+        longTermCoverage: 0.8,
+        backfilledEpochs: [119, 118],
+      },
+    })
+    expect(mocks.info).toHaveBeenCalledWith('[sync:scores] starting')
+    expect(mocks.info).toHaveBeenCalledWith(
+      '[sync:scores] backfill epoch 119 (1/2): calculating 3 validator(s)',
+    )
+    expect(mocks.info).toHaveBeenCalledWith(
+      '[sync:scores] finished; v1 3, v2 2, backfilled 2 epoch(s)',
+    )
+    expect(mocks.sendSyncFailureNotification).not.toHaveBeenCalled()
+  })
+})
diff --git a/server/tasks/sync/scores.ts b/server/tasks/sync/scores.ts
new file mode 100644
index 00000000..6a1dbda1
--- /dev/null
+++ b/server/tasks/sync/scores.ts
@@ -0,0 +1,57 @@
+import { consola } from 'consola'
+import { upsertScoresSnapshotEpoch } from '../../utils/scores'
+import { sendSyncFailureNotification } from '../../utils/slack'
+
+export default defineTask({
+  meta: {
+    name: 'sync:scores',
+    description: 'Calculate and persist validator scores',
+  },
+  async run() {
+    consola.info('[sync:scores] starting')
+    try {
+      const [success, error, data] = await upsertScoresSnapshotEpoch({
+        onProgress: message => consola.info(`[sync:scores] ${message}`),
+      })
+      if (!success || !data) {
+        const scoreError = new Error(error || 'Unable to calculate scores')
+        await sendSyncFailureNotification('scores', scoreError)
+        consola.error(`[sync:scores] failed: ${scoreError.message}`)
+        return { result: { success: false, error } }
+      }
+
+      if (data.dataStatus === 'stale') {
+        consola.info(`[sync:scores] deferred; ${data.missingEpochs.length} recent epoch(s) missing`)
+        return {
+          result: {
+            success: true,
+            dataStatus: 'stale',
+            missingEpochs: data.missingEpochs,
+            scoreCounts: data.scoreCounts,
+            recentCoverage: data.recentCoverage,
+            longTermCoverage: data.longTermCoverage,
+            backfilledEpochs: data.backfilledEpochs,
+          },
+        }
+      }
+
+      consola.info(`[sync:scores] finished; v1 ${data.scoreCounts.v1}, v2 ${data.scoreCounts.v2}, backfilled ${data.backfilledEpochs.length} epoch(s)`)
+      return {
+        result: {
+          success: true,
+          dataStatus: 'complete',
+          epochNumber: data.range.toEpoch,
+          scoreCounts: data.scoreCounts,
+          recentCoverage: data.recentCoverage,
+          longTermCoverage: data.longTermCoverage,
+          backfilledEpochs: data.backfilledEpochs,
+        },
+      }
+    }
+    catch (error) {
+      await sendSyncFailureNotification('scores', error)
+      consola.error('[sync:scores] failed', error)
+      return { result: { success: false, error: String(error) } }
+    }
+  },
+})
diff --git a/server/tasks/sync/snapshot.test.ts b/server/tasks/sync/snapshot.test.ts
new file mode 100644
index 00000000..b509b9f0
--- /dev/null
+++ b/server/tasks/sync/snapshot.test.ts
@@ -0,0 +1,97 @@
+import { afterAll, beforeEach, describe, expect, it, vi } from 'vitest'
+
+const mocks = vi.hoisted(() => ({
+  initRpcClient: vi.fn(),
+  getRpcUrl: vi.fn(),
+  importValidatorsBundled: vi.fn(),
+  fetchActiveEpoch: vi.fn(),
+  upsertScoresSnapshotEpoch: vi.fn(),
+  sendSyncFailureNotification: vi.fn(),
+}))
+
+vi.mock('nimiq-rpc-client-ts/client', () => ({
+  initRpcClient: mocks.initRpcClient,
+}))
+
+vi.mock('../../utils/rpc', () => ({
+  getRpcUrl: mocks.getRpcUrl,
+}))
+
+vi.mock('../../utils/slack', () => ({
+  sendSyncFailureNotification: mocks.sendSyncFailureNotification,
+}))
+
+vi.stubGlobal('defineTask', (task: unknown) => task)
+vi.stubGlobal('useSafeRuntimeConfig', () => ({ public: { nimiqNetwork: 'testnet' } }))
+vi.stubGlobal('importValidatorsBundled', mocks.importValidatorsBundled)
+vi.stubGlobal('fetchActiveEpoch', mocks.fetchActiveEpoch)
+vi.stubGlobal('upsertScoresSnapshotEpoch', mocks.upsertScoresSnapshotEpoch)
+
+type SnapshotSyncTask = typeof import('./snapshot')['default']
+let task: SnapshotSyncTask
+
+beforeEach(async () => {
+  vi.resetAllMocks()
+  const epochNumber = 101
+
+  mocks.getRpcUrl.mockReturnValue('http://rpc.test')
+  mocks.importValidatorsBundled.mockResolvedValue([true, undefined, [{}]])
+  mocks.fetchActiveEpoch.mockResolvedValue([true, undefined, {
+    epochNumber,
+    electedValidators: [],
+    unelectedValidators: [],
+    untrackedValidators: [],
+    deletedValidators: [],
+    unlistedActiveValidators: [],
+    storageOutcome: 'provisioning',
+  }])
+  mocks.upsertScoresSnapshotEpoch.mockResolvedValue([true, undefined, {}])
+  mocks.sendSyncFailureNotification.mockResolvedValue(undefined)
+
+  vi.resetModules()
+  task = (await import('./snapshot')).default
+})
+
+afterAll(() => {
+  vi.unstubAllGlobals()
+})
+
+describe('active snapshot validator provisioning', () => {
+  it('defers score persistence without reporting a bounded provisioning pass as failure', async () => {
+    const result = await task.run()
+
+    expect(result).toEqual({
+      result: {
+        success: true,
+        epochNumber: 101,
+        storageOutcome: 'provisioning',
+      },
+    })
+    expect(mocks.upsertScoresSnapshotEpoch).not.toHaveBeenCalled()
+    expect(mocks.sendSyncFailureNotification).not.toHaveBeenCalled()
+  })
+
+  it('never calculates or persists scores directly after snapshot activity is stored', async () => {
+    mocks.fetchActiveEpoch.mockResolvedValueOnce([true, undefined, {
+      epochNumber: 101,
+      electedValidators: [],
+      unelectedValidators: [],
+      untrackedValidators: [],
+      deletedValidators: [],
+      unlistedActiveValidators: [],
+      storageOutcome: 'stored',
+    }])
+
+    const result = await task.run()
+
+    expect(result).toEqual({
+      result: {
+        success: true,
+        epochNumber: 101,
+        storageOutcome: 'stored',
+      },
+    })
+    expect(mocks.upsertScoresSnapshotEpoch).not.toHaveBeenCalled()
+    expect(mocks.sendSyncFailureNotification).not.toHaveBeenCalled()
+  })
+})
diff --git a/server/tasks/sync/snapshot.ts b/server/tasks/sync/snapshot.ts
index 4f90289f..2c00beba 100644
--- a/server/tasks/sync/snapshot.ts
+++ b/server/tasks/sync/snapshot.ts
@@ -5,7 +5,7 @@ import { sendSyncFailureNotification } from '~~/server/utils/slack'
 export default defineTask({
   meta: {
     name: 'sync:snapshot',
-    description: 'Sync validator snapshot and calculate scores',
+    description: 'Sync validator snapshot',
   },
   async run() {
     const config = useSafeRuntimeConfig()
@@ -31,15 +31,23 @@ export default defineTask({
         await sendSyncFailureNotification('snapshot', error)
         return { result: { success: false, error: fetchActiveEpochError } }
       }
-
-      const [scoresSuccess, errorScores, scores] = await upsertScoresSnapshotEpoch()
-      if (!scoresSuccess || !scores) {
-        const error = new Error(errorScores || 'Unable to fetch scores')
-        await sendSyncFailureNotification('snapshot', error)
-        return { result: { success: false, error: errorScores } }
+      if (fetchActiveEpochData.storageOutcome === 'provisioning') {
+        return {
+          result: {
+            success: true,
+            epochNumber: fetchActiveEpochData.epochNumber,
+            storageOutcome: 'provisioning',
+          },
+        }
       }
 
-      return { result: { success: true, epochNumber: fetchActiveEpochData.epochNumber } }
+      return {
+        result: {
+          success: true,
+          epochNumber: fetchActiveEpochData.epochNumber,
+          storageOutcome: 'stored',
+        },
+      }
     }
     catch (error) {
       await sendSyncFailureNotification('snapshot', error)
diff --git a/server/test/db-harness.ts b/server/test/db-harness.ts
new file mode 100644
index 00000000..72b47024
--- /dev/null
+++ b/server/test/db-harness.ts
@@ -0,0 +1,159 @@
+import type { Client, InArgs, ResultSet } from '@libsql/client'
+import type { LibSQLDatabase } from 'drizzle-orm/libsql'
+import { createClient } from '@libsql/client'
+import { drizzle } from 'drizzle-orm/libsql'
+import * as schema from '../db/schema'
+
+const CREATE_TEST_SCHEMA = `
+PRAGMA foreign_keys = ON;
+
+CREATE TABLE validators (
+  id integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+  name text DEFAULT 'Unknown validator' NOT NULL,
+  address text NOT NULL UNIQUE,
+  description text,
+  fee real DEFAULT -1,
+  payout_type text DEFAULT 'none',
+  payout_schedule text,
+  is_maintained_by_nimiq integer DEFAULT 0,
+  logo text NOT NULL,
+  has_default_logo integer DEFAULT 1 NOT NULL,
+  accent_color text NOT NULL,
+  website text,
+  contact text,
+  is_listed integer
+);
+
+CREATE TABLE scores (
+  validator_id integer NOT NULL REFERENCES validators(id) ON DELETE CASCADE,
+  epoch_number integer NOT NULL,
+  score_version integer DEFAULT 1 NOT NULL CHECK(score_version IN (1, 2)),
+  total real NOT NULL,
+  availability real NOT NULL,
+  recent_availability real,
+  long_term_availability real,
+  dominance real NOT NULL,
+  reliability real NOT NULL,
+  data_status text DEFAULT 'complete' NOT NULL CHECK(data_status IN ('complete', 'stale')),
+  long_term_coverage real,
+  long_term_as_of_epoch integer,
+  PRIMARY KEY (validator_id, epoch_number, score_version)
+);
+
+CREATE INDEX idx_validator_id ON scores(validator_id);
+CREATE INDEX idx_scores_validator_version_epoch ON scores(validator_id, score_version, epoch_number);
+
+CREATE TABLE activity (
+  validator_id integer NOT NULL REFERENCES validators(id) ON DELETE CASCADE,
+  epoch_number integer NOT NULL,
+  likelihood integer NOT NULL,
+  rewarded integer NOT NULL,
+  missed integer NOT NULL,
+  dominance_ratio_via_balance integer NOT NULL,
+  dominance_ratio_via_slots integer NOT NULL,
+  balance real DEFAULT -1 NOT NULL,
+  stakers integer DEFAULT 0 NOT NULL,
+  PRIMARY KEY (validator_id, epoch_number)
+);
+
+CREATE INDEX idx_election_block ON activity(epoch_number);
+
+CREATE TABLE activity_epochs (
+  epoch_number integer PRIMARY KEY NOT NULL,
+  status text NOT NULL CHECK(status IN ('syncing', 'finalized', 'failed')),
+  expected_elected_count integer,
+  stored_elected_count integer,
+  elected_set_hash text,
+  attempt_count integer DEFAULT 0 NOT NULL,
+  started_at text NOT NULL,
+  finalized_at text,
+  last_error text,
+  CHECK(
+    (expected_elected_count IS NULL OR expected_elected_count >= 0)
+    AND (stored_elected_count IS NULL OR stored_elected_count >= 0)
+    AND attempt_count >= 0
+  ),
+  CHECK(
+    status != 'finalized' OR (
+      expected_elected_count IS NOT NULL
+      AND stored_elected_count IS NOT NULL
+      AND expected_elected_count = stored_elected_count
+      AND elected_set_hash IS NOT NULL
+      AND length(trim(elected_set_hash, ' ' || char(9) || char(10) || char(13))) > 0
+      AND length(trim(started_at, ' ' || char(9) || char(10) || char(13))) > 0
+      AND finalized_at IS NOT NULL
+      AND length(trim(finalized_at, ' ' || char(9) || char(10) || char(13))) > 0
+      AND last_error IS NULL
+    )
+  )
+);
+
+CREATE INDEX idx_activity_epochs_status ON activity_epochs(status);
+CREATE INDEX idx_activity_epochs_finalized ON activity_epochs(status, epoch_number);
+`
+
+export interface TestDbTrace {
+  executed: string[]
+  batches: string[][]
+  reset: () => void
+}
+
+export interface TestDbHarness {
+  client: Client
+  db: LibSQLDatabase<typeof schema>
+  trace: TestDbTrace
+  execute: (sql: string, args?: InArgs) => Promise<ResultSet>
+  close: () => void
+}
+
+function getStatementSql(statement: unknown): string {
+  if (typeof statement === 'string')
+    return statement
+  if (Array.isArray(statement) && typeof statement[0] === 'string')
+    return statement[0]
+  if (statement && typeof statement === 'object' && 'sql' in statement && typeof statement.sql === 'string')
+    return statement.sql
+  return String(statement)
+}
+
+export async function createTestDbHarness(): Promise<TestDbHarness> {
+  const rawClient = createClient({ url: 'file::memory:' })
+  await rawClient.executeMultiple(CREATE_TEST_SCHEMA)
+
+  const trace: TestDbTrace = {
+    executed: [],
+    batches: [],
+    reset() {
+      this.executed.length = 0
+      this.batches.length = 0
+    },
+  }
+  const client = new Proxy(rawClient, {
+    get(target, property) {
+      if (property === 'execute') {
+        return (...args: Parameters<Client['execute']>) => {
+          trace.executed.push(getStatementSql(args[0]))
+          return Reflect.apply(target.execute, target, args)
+        }
+      }
+      if (property === 'batch') {
+        return (...args: Parameters<Client['batch']>) => {
+          trace.batches.push(args[0].map(getStatementSql))
+          return Reflect.apply(target.batch, target, args)
+        }
+      }
+
+      const value = Reflect.get(target, property, target)
+      return typeof value === 'function' ? value.bind(target) : value
+    },
+  }) as Client
+  const db = drizzle(client, { schema })
+
+  return {
+    client,
+    db,
+    trace,
+    execute: (sql, args) => client.execute(sql, args),
+    close: () => client.close(),
+  }
+}
diff --git a/server/utils/activities.ts b/server/utils/activities.ts
index d89d6630..e288c15a 100644
--- a/server/utils/activities.ts
+++ b/server/utils/activities.ts
@@ -1,64 +1,285 @@
-import type { ElectedValidator, EpochActivity, EpochsActivities, Range, Result, UnelectedValidator } from 'nimiq-validator-trustscore/types'
+import type { ElectedValidator, ElectionSet, EpochActivity, EpochsActivities, Range, Result, UnelectedValidator } from 'nimiq-validator-trustscore/types'
 import type { NewActivity } from './drizzle'
-import type { SnapshotEpochValidators, SyncStreamReportFn } from './types'
+import type { StoredSnapshotEpochValidators, SyncStreamReportFn } from './types'
 import { consola } from 'consola'
-import { and, desc, eq, gte, lte, not, or } from 'drizzle-orm'
+import { and, desc, eq, gte, lte, not, or, sql } from 'drizzle-orm'
 import { fetchEpochs } from 'nimiq-validator-trustscore/fetcher'
 import { getRange } from 'nimiq-validator-trustscore/range'
-import { isCompleteFinalizedEpochActivity } from './activity-completeness'
+import {
+  beginActivityEpochAttempt,
+  calculateActivityCoverage,
+  markActivityEpochFailed,
+  persistCompletedEpoch,
+  prepareCompletedEpoch,
+} from './activity-epochs'
+import { canonicalizeValidatorAddress } from './activity-integrity'
 import { resolveLiveActivityMetadata } from './activity-metadata'
-import { storeValidator } from './validators'
+import { categorizeValidatorsSnapshotEpoch, storeValidator, storeValidatorStrict } from './validators'
 
 /**
  * Given a range, it returns the epochs that are missing in the database.
  */
 export async function findMissingEpochs(range: Range) {
-  const activityRows = await useDrizzle()
-    .select({
-      epochNumber: tables.activity.epochNumber,
-      likelihood: tables.activity.likelihood,
-      missed: tables.activity.missed,
-      rewarded: tables.activity.rewarded,
-    })
-    .from(tables.activity)
+  const finalizedEpochs = await useDrizzle()
+    .select({ epochNumber: tables.activityEpochs.epochNumber })
+    .from(tables.activityEpochs)
     .where(and(
-      gte(tables.activity.epochNumber, range.fromEpoch),
-      lte(tables.activity.epochNumber, range.toEpoch),
+      eq(tables.activityEpochs.status, 'finalized'),
+      gte(tables.activityEpochs.epochNumber, range.fromEpoch),
+      lte(tables.activityEpochs.epochNumber, range.toEpoch),
     ))
     .all()
 
-  const epochs = new Map<number, typeof activityRows>()
-  for (const row of activityRows) {
-    const rows = epochs.get(row.epochNumber) || []
-    rows.push(row)
-    epochs.set(row.epochNumber, rows)
-  }
-
-  const missingEpochs = []
-  for (let i = range.fromEpoch; i <= range.toEpoch; i++) {
-    if (!isCompleteFinalizedEpochActivity(epochs.get(i) || []))
-      missingEpochs.push(i)
-  }
-  return missingEpochs
+  return calculateActivityCoverage(
+    range.fromEpoch,
+    range.toEpoch,
+    finalizedEpochs.map(({ epochNumber }) => epochNumber),
+  ).missingEpochs
 }
 
 /**
  * We loop over all the pairs activities/epochBlockNumber and store the validator activities.
  */
-interface StoreActivitiesOptions {
+export interface StoreActivitiesOptions {
   finalizeEpoch?: boolean
+  electionSets?: Readonly<Record<number, ElectionSet>>
+}
+
+export interface StoreActivitiesResult {
+  storedEpochs: number[]
+  alreadyFinalizedEpochs: number[]
+  provisioningEpochs: number[]
+}
+
+export interface CompletedEpochValidatorResolution {
+  validatorIds: Map<string, number>
+  complete: boolean
+}
+
+const MAX_VALIDATOR_PROVISIONS_PER_INVOCATION = 200
+const ACTIVITY_UPSERT_CHUNK_SIZE = 5
+const defaultActivity: ElectedValidator = { likelihood: -1, balance: -1, dominanceRatioViaBalance: -1, dominanceRatioViaSlots: -1, missed: -1, rewarded: -1, address: '', elected: true, stakers: 0 }
+
+export async function resolveCompletedEpochValidatorIds(
+  addresses: readonly string[],
+  maxProvisions = MAX_VALIDATOR_PROVISIONS_PER_INVOCATION,
+): Promise<CompletedEpochValidatorResolution> {
+  const storedValidators = await useDrizzle()
+    .select({ id: tables.validators.id, address: tables.validators.address })
+    .from(tables.validators)
+    .all()
+  const validatorIdByCanonicalAddress = new Map<string, number>()
+  for (const validator of storedValidators) {
+    const canonicalAddress = canonicalizeValidatorAddress(validator.address)
+    const existingId = validatorIdByCanonicalAddress.get(canonicalAddress)
+    if (existingId !== undefined && existingId !== validator.id)
+      throw new Error(`Duplicate stored canonical validator address: ${canonicalAddress}`)
+    validatorIdByCanonicalAddress.set(canonicalAddress, validator.id)
+  }
+
+  const resolvedValidatorIds = new Map<string, number>()
+  const resolvedCanonicalAddresses = new Set<string>()
+  const missingAddresses: Array<{ address: string, canonicalAddress: string }> = []
+  for (const address of addresses) {
+    const canonicalAddress = canonicalizeValidatorAddress(address)
+    if (resolvedCanonicalAddresses.has(canonicalAddress))
+      throw new Error(`Duplicate election-set validator address: ${canonicalAddress}`)
+    resolvedCanonicalAddresses.add(canonicalAddress)
+
+    const validatorId = validatorIdByCanonicalAddress.get(canonicalAddress)
+    if (validatorId === undefined)
+      missingAddresses.push({ address, canonicalAddress })
+    else
+      resolvedValidatorIds.set(address, validatorId)
+  }
+
+  const addressesToProvision = missingAddresses.slice(0, maxProvisions)
+  for (const { address, canonicalAddress } of addressesToProvision) {
+    const validatorId = await storeValidatorStrict(address)
+    validatorIdByCanonicalAddress.set(canonicalAddress, validatorId)
+    resolvedValidatorIds.set(address, validatorId)
+  }
+
+  return {
+    validatorIds: resolvedValidatorIds,
+    complete: missingAddresses.length <= maxProvisions,
+  }
+}
+
+async function storeNonFinalizedActivities(epochNumber: number, activities: EpochActivity): Promise<'stored' | 'provisioning'> {
+  const activityEntries = Object.entries(activities)
+  if (activityEntries.length === 0)
+    return 'stored'
+
+  const db = useDrizzle()
+  const resolution = await resolveCompletedEpochValidatorIds(activityEntries.map(([address]) => address))
+  if (!resolution.complete)
+    return 'provisioning'
+
+  const storedRows = await db.select({
+    validatorId: tables.activity.validatorId,
+    likelihood: tables.activity.likelihood,
+    rewarded: tables.activity.rewarded,
+    missed: tables.activity.missed,
+    dominanceRatioViaSlots: tables.activity.dominanceRatioViaSlots,
+    dominanceRatioViaBalance: tables.activity.dominanceRatioViaBalance,
+    balance: tables.activity.balance,
+    stakers: tables.activity.stakers,
+  }).from(tables.activity).where(eq(tables.activity.epochNumber, epochNumber)).all()
+  const latestLiveEpochs = db.select({
+    validatorId: tables.activity.validatorId,
+    epochNumber: sql<number>`max(${tables.activity.epochNumber})`.as('latest_epoch_number'),
+  }).from(tables.activity).where(or(
+    gte(tables.activity.balance, 0),
+    gte(tables.activity.stakers, 1),
+  )).groupBy(tables.activity.validatorId).as('latest_live_activity')
+  const latestLiveRows = await db.select({
+    validatorId: tables.activity.validatorId,
+    balance: tables.activity.balance,
+    stakers: tables.activity.stakers,
+  }).from(tables.activity).innerJoin(latestLiveEpochs, and(
+    eq(tables.activity.validatorId, latestLiveEpochs.validatorId),
+    eq(tables.activity.epochNumber, latestLiveEpochs.epochNumber),
+  )).all()
+  const storedByValidatorId = new Map(storedRows.map(row => [row.validatorId, row]))
+  const latestLiveByValidatorId = new Map(latestLiveRows.map(row => [row.validatorId, row]))
+  const activityRows = activityEntries.map(([address, activity]): NewActivity => {
+    const validatorId = resolution.validatorIds.get(address)
+    if (validatorId === undefined)
+      throw new Error(`Failed to resolve validator ID for ${address}`)
+
+    const stored = storedByValidatorId.get(validatorId) || defaultActivity
+    const dominanceRatioViaSlots = stored.dominanceRatioViaSlots !== -1
+      ? stored.dominanceRatioViaSlots
+      : activity.dominanceRatioViaSlots
+    const dominanceRatioViaBalance = stored.dominanceRatioViaBalance !== -1
+      ? stored.dominanceRatioViaBalance
+      : activity.dominanceRatioViaBalance
+    const { balance, stakers } = resolveLiveActivityMetadata(
+      stored,
+      activity,
+      latestLiveByValidatorId.get(validatorId),
+    )
+
+    return {
+      validatorId,
+      epochNumber,
+      likelihood: activity.likelihood,
+      rewarded: activity.rewarded,
+      missed: activity.missed,
+      dominanceRatioViaBalance,
+      dominanceRatioViaSlots,
+      balance,
+      stakers,
+    }
+  })
+  const finalizedEpochGuard = db.update(tables.activityEpochs).set({
+    // Force the snapshot batch to roll back if this epoch finalized after it was fetched.
+    startedAt: sql`CASE
+      WHEN ${tables.activityEpochs.status} = 'finalized' THEN NULL
+      ELSE ${tables.activityEpochs.startedAt}
+    END`,
+  }).where(eq(tables.activityEpochs.epochNumber, epochNumber))
+  const statements = Array.from(
+    { length: Math.ceil(activityRows.length / ACTIVITY_UPSERT_CHUNK_SIZE) },
+    (_, chunkIndex) => {
+      const fromIndex = chunkIndex * ACTIVITY_UPSERT_CHUNK_SIZE
+      const activityChunk = activityRows.slice(fromIndex, fromIndex + ACTIVITY_UPSERT_CHUNK_SIZE)
+      return db.insert(tables.activity).values(activityChunk).onConflictDoUpdate({
+        target: [tables.activity.validatorId, tables.activity.epochNumber],
+        set: {
+          likelihood: sql`excluded.likelihood`,
+          rewarded: sql`excluded.rewarded`,
+          missed: sql`excluded.missed`,
+          dominanceRatioViaBalance: sql`excluded.dominance_ratio_via_balance`,
+          dominanceRatioViaSlots: sql`excluded.dominance_ratio_via_slots`,
+          balance: sql`excluded.balance`,
+          stakers: sql`excluded.stakers`,
+        },
+      })
+    },
+  )
+  await db.batch([finalizedEpochGuard, ...statements])
+  return 'stored'
 }
 
 export async function storeActivities(epochs: EpochsActivities, options: StoreActivitiesOptions = {}) {
-  const promises = Object.entries(epochs).map(async ([_epochNumber, activities]) => {
+  const result: StoreActivitiesResult = {
+    storedEpochs: [],
+    alreadyFinalizedEpochs: [],
+    provisioningEpochs: [],
+  }
+  if (!options.finalizeEpoch) {
+    for (const [_epochNumber, activities] of Object.entries(epochs)) {
+      const epochNumber = Number(_epochNumber)
+      const outcome = await storeNonFinalizedActivities(epochNumber, activities)
+      if (outcome === 'provisioning') {
+        result.provisioningEpochs.push(epochNumber)
+        return result
+      }
+      result.storedEpochs.push(epochNumber)
+    }
+    return result
+  }
+
+  for (const [_epochNumber, activities] of Object.entries(epochs)) {
     const epochNumber = Number(_epochNumber)
-    const activePromises = Object.entries(activities)
-      .map(async ([address, activity]) => storeSingleActivity({ address, activity, epochNumber }))
-    await Promise.all(activePromises)
-    if (options.finalizeEpoch)
-      await clearStaleElectedPlaceholders({ epochNumber, finalizedAddresses: Object.keys(activities) })
+    const electionSet = options.electionSets?.[epochNumber]
+    if (!electionSet)
+      throw new Error(`Authoritative election set is required to finalize epoch ${epochNumber}`)
+
+    const startedAt = new Date().toISOString()
+    const claimed = await beginActivityEpochAttempt(epochNumber, startedAt)
+    if (!claimed) {
+      result.alreadyFinalizedEpochs.push(epochNumber)
+      continue
+    }
+
+    try {
+      const resolution = await resolveCompletedEpochValidatorIds(
+        electionSet.validators.map(({ address }) => address),
+      )
+      if (!resolution.complete) {
+        result.provisioningEpochs.push(epochNumber)
+        return result
+      }
+
+      const prepared = await prepareCompletedEpoch({
+        epochNumber,
+        electionSet,
+        activity: activities,
+        validatorIds: resolution.validatorIds,
+      })
+      await persistCompletedEpoch(prepared, startedAt, new Date().toISOString())
+      result.storedEpochs.push(epochNumber)
+    }
+    catch (error) {
+      await markActivityEpochFailed(epochNumber, error, startedAt)
+      throw error
+    }
+  }
+  return result
+}
+
+export async function repairCompletedEpoch(
+  epochNumber: number,
+  electionSet: ElectionSet,
+  activity: EpochActivity,
+  startedAt: string,
+): Promise<void> {
+  const resolution = await resolveCompletedEpochValidatorIds(
+    electionSet.validators.map(({ address }) => address),
+  )
+  if (!resolution.complete)
+    throw new Error(`Validator provisioning is incomplete for completed epoch ${epochNumber}`)
+
+  const prepared = await prepareCompletedEpoch({
+    epochNumber,
+    electionSet,
+    activity,
+    validatorIds: resolution.validatorIds,
   })
-  await Promise.all(promises)
+  await persistCompletedEpoch(prepared, startedAt, new Date().toISOString())
 }
 
 interface ClearStaleElectedPlaceholdersParams {
@@ -108,8 +329,6 @@ interface StoreActivityParams {
   epochNumber: number
 }
 
-const defaultActivity: ElectedValidator = { likelihood: -1, balance: -1, dominanceRatioViaBalance: -1, dominanceRatioViaSlots: -1, missed: -1, rewarded: -1, address: '', elected: true, stakers: 0 }
-
 async function fetchLatestActivityMetadata(validatorId: number) {
   return useDrizzle()
     .select({
@@ -133,8 +352,6 @@ export async function storeSingleActivity({ address, activity, epochNumber }: St
   const validatorId = await storeValidator(address)
   if (!validatorId)
     return
-  // If we ever move out of cloudflare we could use transactions to avoid inconsistencies and improve performance
-  // Cloudflare D1 does not support transactions: https://github.com/cloudflare/workerd/blob/e78561270004797ff008f17790dae7cfe4a39629/src/workerd/api/sql-test.js#L252-L253
   const stored = await useDrizzle()
     .select({
       likelihood: tables.activity.likelihood,
@@ -157,12 +374,19 @@ export async function storeSingleActivity({ address, activity, epochNumber }: St
   const latestActivityMetadata = await fetchLatestActivityMetadata(validatorId)
   const { balance, stakers } = resolveLiveActivityMetadata(stored, activity || defaultActivity, latestActivityMetadata)
 
-  await useDrizzle().delete(tables.activity).where(and(
-    eq(tables.activity.epochNumber, epochNumber),
-    eq(tables.activity.validatorId, validatorId),
-  ))
   const activityDb: NewActivity = { ...activity!, epochNumber, validatorId, dominanceRatioViaSlots, dominanceRatioViaBalance, balance, stakers }
-  await useDrizzle().insert(tables.activity).values(activityDb)
+  await useDrizzle().insert(tables.activity).values(activityDb).onConflictDoUpdate({
+    target: [tables.activity.validatorId, tables.activity.epochNumber],
+    set: {
+      likelihood: activityDb.likelihood,
+      rewarded: activityDb.rewarded,
+      missed: activityDb.missed,
+      dominanceRatioViaBalance: activityDb.dominanceRatioViaBalance,
+      dominanceRatioViaSlots: activityDb.dominanceRatioViaSlots,
+      balance: activityDb.balance,
+      stakers: activityDb.stakers,
+    },
+  }).execute()
 }
 
 interface FetchMissingEpochsParams {
@@ -253,7 +477,7 @@ export async function fetchMissingEpochs({ report, controller }: FetchMissingEpo
   return [true, undefined, Array.from(processedEpochs)]
 }
 
-export async function fetchActiveEpoch(): Result<SnapshotEpochValidators> {
+export async function fetchActiveEpoch(): Result<StoredSnapshotEpochValidators> {
   const [success, error, data] = await categorizeValidatorsSnapshotEpoch()
   if (!success || !data)
     return [false, error || 'No active epoch', undefined]
@@ -261,7 +485,6 @@ export async function fetchActiveEpoch(): Result<SnapshotEpochValidators> {
   const untrackedAddresses = data.untrackedValidators.map(v => v.address)
   if (untrackedAddresses.length > 0)
     consola.warn(`Found ${untrackedAddresses.length} untracked validators in the current epoch.`, untrackedAddresses)
-  await Promise.all(untrackedAddresses.map(address => storeValidator(address)))
 
   // Now we transform the data so we can use the same functions as if the epoch was finished
   // The following fields are the ones that cannot be computed at the moment, and we will compute them later
@@ -272,7 +495,11 @@ export async function fetchActiveEpoch(): Result<SnapshotEpochValidators> {
     activity[address] = { address, ...rest }
   consola.info(`Fetched active epoch: ${data.epochNumber} ()`)
   const epochActivity: EpochsActivities = { [data.epochNumber]: activity }
-  await storeActivities(epochActivity)
+  const storeResult = await storeActivities(epochActivity)
+  if (storeResult.provisioningEpochs.includes(data.epochNumber))
+    return [true, undefined, { ...data, storageOutcome: 'provisioning' }]
+  if (!storeResult.storedEpochs.includes(data.epochNumber))
+    return [false, `Active epoch ${data.epochNumber} storage returned no outcome`, undefined]
 
-  return [true, undefined, data]
+  return [true, undefined, { ...data, storageOutcome: 'stored' }]
 }
diff --git a/server/utils/activity-completeness.test.ts b/server/utils/activity-completeness.test.ts
deleted file mode 100644
index 8714ab47..00000000
--- a/server/utils/activity-completeness.test.ts
+++ /dev/null
@@ -1,38 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { isCompleteFinalizedEpochActivity, isElectedSnapshotPlaceholder, isFinalizedEpochActivity } from './activity-completeness'
-
-describe('activity completeness', () => {
-  it('does not treat current-epoch snapshot placeholders as finalized activity', () => {
-    expect(isFinalizedEpochActivity({ likelihood: 0.1, missed: -1, rewarded: -1 })).toBe(false)
-  })
-
-  it('treats finalized elected rows with zero rewards and misses as finalized activity', () => {
-    expect(isFinalizedEpochActivity({ likelihood: 0.1, missed: 0, rewarded: 0 })).toBe(true)
-  })
-
-  it('does not treat unelected rows as finalized activity', () => {
-    expect(isFinalizedEpochActivity({ likelihood: -1, missed: -1, rewarded: -1 })).toBe(false)
-  })
-
-  it('identifies elected current-epoch placeholders', () => {
-    expect(isElectedSnapshotPlaceholder({ likelihood: 0.1, missed: -1, rewarded: -1 })).toBe(true)
-  })
-
-  it('does not identify finalized activity as a snapshot placeholder', () => {
-    expect(isElectedSnapshotPlaceholder({ likelihood: 0.1, missed: 0, rewarded: 720 })).toBe(false)
-  })
-
-  it('does not treat an epoch as complete while any elected placeholder remains', () => {
-    expect(isCompleteFinalizedEpochActivity([
-      { likelihood: 0.1, missed: 0, rewarded: 720 },
-      { likelihood: 0.1, missed: -1, rewarded: -1 },
-    ])).toBe(false)
-  })
-
-  it('treats an epoch as complete when finalized rows have no elected placeholders', () => {
-    expect(isCompleteFinalizedEpochActivity([
-      { likelihood: 0.1, missed: 0, rewarded: 720 },
-      { likelihood: -1, missed: 0, rewarded: 0 },
-    ])).toBe(true)
-  })
-})
diff --git a/server/utils/activity-completeness.ts b/server/utils/activity-completeness.ts
deleted file mode 100644
index 30f27551..00000000
--- a/server/utils/activity-completeness.ts
+++ /dev/null
@@ -1,17 +0,0 @@
-interface EpochActivityCompletenessFields {
-  likelihood: number
-  missed: number
-  rewarded: number
-}
-
-export function isFinalizedEpochActivity({ likelihood, missed, rewarded }: EpochActivityCompletenessFields) {
-  return likelihood !== -1 && missed >= 0 && rewarded >= 0
-}
-
-export function isElectedSnapshotPlaceholder({ likelihood, missed, rewarded }: EpochActivityCompletenessFields) {
-  return likelihood !== -1 && missed < 0 && rewarded < 0
-}
-
-export function isCompleteFinalizedEpochActivity(rows: EpochActivityCompletenessFields[]) {
-  return rows.some(isFinalizedEpochActivity) && !rows.some(isElectedSnapshotPlaceholder)
-}
diff --git a/server/utils/activity-epochs.test.ts b/server/utils/activity-epochs.test.ts
new file mode 100644
index 00000000..712998c2
--- /dev/null
+++ b/server/utils/activity-epochs.test.ts
@@ -0,0 +1,331 @@
+import type { ElectionSet, EpochActivity, Range } from 'nimiq-validator-trustscore/types'
+import { describe, expect, it, vi } from 'vitest'
+import {
+  calculateActivityCoverage,
+  getRecentEpochRange,
+  planEpochSync,
+  prepareCompletedEpoch,
+} from './activity-epochs'
+
+vi.mock('./drizzle', () => ({
+  tables: {},
+  useDrizzle: () => {
+    throw new Error('Database access is not available in pure activity epoch tests')
+  },
+}))
+
+const HOUR_MS = 60 * 60 * 1000
+const DAY_MS = 24 * HOUR_MS
+const ADDRESS_A = 'NQ02 31N6 3KM5 T6G5 22TN EPF5 5XPY RLHK RMB3'
+const ADDRESS_A_CANONICAL = 'NQ0231N63KM5T6G522TNEPF55XPYRLHKRMB3'
+const ADDRESS_B = 'NQ29 FBVT B4GM S27H UBP4 1MTC GNKQ VPBT 099M'
+const ADDRESS_B_CANONICAL = 'NQ29FBVTB4GMS27HUBP41MTCGNKQVPBT099M'
+const ADDRESS_C = 'NQ40 FC4D HAT6 9N1H P52H P4FX QL8P CE6Y 10VT'
+const EXPECTED_ELECTION_SET_HASH = 'ff5c7e71ebf54f0ca2d57a4adefc3c3a7d0b1d10bcb1b69b653431d047cdacbd'
+
+function createRange(overrides: Partial<Range> = {}): Range {
+  const fromEpoch = overrides.fromEpoch ?? 1
+  const toEpoch = overrides.toEpoch ?? 100
+  const epochDurationMs = overrides.epochDurationMs ?? 12 * HOUR_MS
+
+  return {
+    head: 1_000_000,
+    headEpoch: toEpoch + 1,
+    epochCount: toEpoch - fromEpoch + 1,
+    epochDurationMs,
+    fromEpoch,
+    fromBlockNumber: 0,
+    fromTimestamp: 0,
+    toEpoch,
+    toBlockNumber: 999_999,
+    toTimestamp: 0,
+    snapshotEpoch: toEpoch + 1,
+    snapshotBlock: 1_000_000,
+    snapshotTimestamp: 0,
+    ...overrides,
+  }
+}
+
+function createElectionSet(addresses = [ADDRESS_A, ADDRESS_B]): ElectionSet {
+  return {
+    epochIndex: 77,
+    electionBlockNumber: 123_456,
+    validators: addresses.map((address, index) => ({ address, numSlots: 10 + index })),
+  }
+}
+
+function createElectedActivity(address: string, likelihood: number) {
+  return {
+    address,
+    elected: true as const,
+    likelihood,
+    missed: 2,
+    rewarded: 718,
+    dominanceRatioViaBalance: -1,
+    dominanceRatioViaSlots: likelihood / 512,
+    balance: -1,
+    stakers: 0,
+  }
+}
+
+function createEpochActivity(): EpochActivity {
+  return {
+    [ADDRESS_B_CANONICAL.toLowerCase()]: createElectedActivity(ADDRESS_B, 11),
+    [ADDRESS_A]: createElectedActivity(ADDRESS_A_CANONICAL.toLowerCase(), 10),
+  }
+}
+
+function createPreparationInput(overrides: Partial<{
+  epochNumber: number
+  electionSet: ElectionSet
+  activity: EpochActivity
+  validatorIds: Map<string, number>
+}> = {}) {
+  return {
+    epochNumber: 77,
+    electionSet: createElectionSet(),
+    activity: createEpochActivity(),
+    validatorIds: new Map<string, number>([
+      [ADDRESS_B.toLowerCase(), 22],
+      [ADDRESS_A_CANONICAL, 11],
+    ]),
+    ...overrides,
+  }
+}
+
+describe('activity epoch ranges and coverage', () => {
+  it('selects the inclusive epochs covering the most recent 14 days', () => {
+    const range = createRange({ fromEpoch: 40, toEpoch: 100, epochDurationMs: 12 * HOUR_MS })
+
+    expect(getRecentEpochRange(range)).toEqual({ fromEpoch: 73, toEpoch: 100 })
+  })
+
+  it('rounds a partial epoch up when covering the requested duration', () => {
+    const range = createRange({ fromEpoch: 40, toEpoch: 100, epochDurationMs: 12 * HOUR_MS - 60_000 })
+
+    expect(getRecentEpochRange(range, 14 * DAY_MS)).toEqual({ fromEpoch: 72, toEpoch: 100 })
+  })
+
+  it('clamps the recent range to the available history', () => {
+    const range = createRange({ fromEpoch: 80, toEpoch: 100, epochDurationMs: 12 * HOUR_MS })
+
+    expect(getRecentEpochRange(range)).toEqual({ fromEpoch: 80, toEpoch: 100 })
+  })
+
+  it('reports inclusive finalized coverage and every missing epoch', () => {
+    expect(calculateActivityCoverage(10, 14, [14, 10, 12])).toEqual({
+      fromEpoch: 10,
+      toEpoch: 14,
+      expectedEpochCount: 5,
+      finalizedEpochCount: 3,
+      coverage: 0.6,
+      missingEpochs: [11, 13],
+    })
+  })
+
+  it('does not inflate coverage with duplicate or out-of-range finalized epochs', () => {
+    expect(calculateActivityCoverage(10, 12, [9, 10, 10, 12, 13])).toEqual({
+      fromEpoch: 10,
+      toEpoch: 12,
+      expectedEpochCount: 3,
+      finalizedEpochCount: 2,
+      coverage: 2 / 3,
+      missingEpochs: [11],
+    })
+  })
+})
+
+describe('activity epoch synchronization planning', () => {
+  const now = '2026-07-28T12:00:00.000Z'
+
+  it('prioritizes latest, recent failed or stale, recent absent, then older failed or absent epochs newest-first', () => {
+    expect(planEpochSync({
+      range: { fromEpoch: 90, toEpoch: 100 },
+      recentRange: { fromEpoch: 97, toEpoch: 100 },
+      markers: [
+        { epochNumber: 99, status: 'failed', startedAt: '2026-07-28T11:00:00.000Z' },
+        { epochNumber: 98, status: 'syncing', startedAt: '2026-07-28T05:59:59.000Z' },
+        { epochNumber: 96, status: 'failed', startedAt: '2026-07-27T12:00:00.000Z' },
+        { epochNumber: 95, status: 'syncing', startedAt: '2026-07-28T00:00:00.000Z' },
+        { epochNumber: 93, status: 'syncing', startedAt: '2026-07-28T11:00:00.000Z' },
+        { epochNumber: 92, status: 'finalized', startedAt: '2026-07-27T12:00:00.000Z' },
+      ],
+      now,
+    })).toEqual([100, 99, 98, 97, 96, 95, 94, 91, 90])
+  })
+
+  it('keeps a fresh syncing lease out of the plan and retries it at the six-hour boundary', () => {
+    const baseInput = {
+      range: { fromEpoch: 40, toEpoch: 42 },
+      recentRange: { fromEpoch: 40, toEpoch: 42 },
+      now,
+    }
+
+    expect(planEpochSync({
+      ...baseInput,
+      markers: [
+        { epochNumber: 42, status: 'finalized', startedAt: '2026-07-28T00:00:00.000Z' },
+        { epochNumber: 41, status: 'syncing', startedAt: '2026-07-28T06:00:01.000Z' },
+        { epochNumber: 40, status: 'finalized', startedAt: '2026-07-28T00:00:00.000Z' },
+      ],
+    })).toEqual([])
+
+    expect(planEpochSync({
+      ...baseInput,
+      markers: [
+        { epochNumber: 42, status: 'finalized', startedAt: '2026-07-28T00:00:00.000Z' },
+        { epochNumber: 41, status: 'syncing', startedAt: '2026-07-28T06:00:00.000Z' },
+        { epochNumber: 40, status: 'finalized', startedAt: '2026-07-28T00:00:00.000Z' },
+      ],
+    })).toEqual([41])
+  })
+
+  it('allows a shorter lease to recover orphaned development attempts', () => {
+    const input = {
+      range: { fromEpoch: 40, toEpoch: 42 },
+      recentRange: { fromEpoch: 40, toEpoch: 42 },
+      markers: [
+        { epochNumber: 42, status: 'finalized' as const, startedAt: '2026-07-28T00:00:00.000Z' },
+        { epochNumber: 41, status: 'syncing' as const, startedAt: '2026-07-28T11:54:59.000Z' },
+        { epochNumber: 40, status: 'finalized' as const, startedAt: '2026-07-28T00:00:00.000Z' },
+      ],
+      now,
+    }
+
+    expect(planEpochSync(input)).toEqual([])
+    expect(planEpochSync({
+      ...input,
+      syncingLeaseDurationMs: 5 * 60 * 1000,
+    })).toEqual([41])
+  })
+
+  it('never schedules finalized epochs', () => {
+    expect(planEpochSync({
+      range: { fromEpoch: 7, toEpoch: 9 },
+      recentRange: { fromEpoch: 7, toEpoch: 9 },
+      markers: [7, 8, 9].map(epochNumber => ({
+        epochNumber,
+        status: 'finalized' as const,
+        startedAt: '2026-07-28T00:00:00.000Z',
+      })),
+      now,
+    })).toEqual([])
+  })
+
+  it('applies the production limit of 50 candidates after priority ordering', () => {
+    const planned = planEpochSync({
+      range: { fromEpoch: 1, toEpoch: 60 },
+      recentRange: { fromEpoch: 50, toEpoch: 60 },
+      markers: [],
+      now,
+    })
+
+    expect(planned).toHaveLength(50)
+    expect(planned).toEqual(Array.from({ length: 50 }, (_, index) => 60 - index))
+  })
+
+  it('returns the entire range when development requests an unlimited plan', () => {
+    const planned = planEpochSync({
+      range: { fromEpoch: 1, toEpoch: 550 },
+      recentRange: { fromEpoch: 522, toEpoch: 550 },
+      markers: [],
+      now,
+      limit: Infinity,
+    })
+
+    expect(planned).toHaveLength(550)
+    expect(new Set(planned)).toEqual(new Set(Array.from({ length: 550 }, (_, index) => index + 1)))
+  })
+})
+
+describe('completed epoch preparation', () => {
+  it('prepares a deterministic exact elected set with validated IDs, counts, and hash', async () => {
+    const prepared = await prepareCompletedEpoch(createPreparationInput())
+
+    expect(prepared).toMatchObject({
+      epochNumber: 77,
+      expectedElectedCount: 2,
+      storedElectedCount: 2,
+      electedSetHash: EXPECTED_ELECTION_SET_HASH,
+    })
+    expect(prepared.activities).toEqual([
+      expect.objectContaining({ validatorId: 11, epochNumber: 77, likelihood: 10, missed: 2, rewarded: 718 }),
+      expect.objectContaining({ validatorId: 22, epochNumber: 77, likelihood: 11, missed: 2, rewarded: 718 }),
+    ])
+  })
+
+  it('rejects a mismatch between the election set and activity keys', async () => {
+    const activity = createEpochActivity()
+    delete activity[ADDRESS_B_CANONICAL.toLowerCase()]
+    activity[ADDRESS_C] = createElectedActivity(ADDRESS_C, 11)
+
+    await expect(prepareCompletedEpoch(createPreparationInput({ activity }))).rejects.toThrow(/election|address|set|mismatch/i)
+  })
+
+  it('rejects an activity whose payload address does not match its key canonically', async () => {
+    const activity = createEpochActivity()
+    activity[ADDRESS_A] = createElectedActivity(ADDRESS_C, 10)
+
+    await expect(prepareCompletedEpoch(createPreparationInput({ activity }))).rejects.toThrow(/address|canonical|mismatch/i)
+  })
+
+  it.each([
+    ['rewarded', 0.5],
+    ['rewarded', Number.NaN],
+    ['rewarded', Number.POSITIVE_INFINITY],
+    ['missed', 0.5],
+    ['missed', Number.NaN],
+    ['missed', Number.POSITIVE_INFINITY],
+  ] as const)('rejects non-integer finalized %s counters: %s', async (counter, value) => {
+    const activity = createEpochActivity()
+    Object.assign(activity[ADDRESS_A]!, { [counter]: value })
+
+    await expect(prepareCompletedEpoch(createPreparationInput({ activity })))
+      .rejects
+      .toThrow(/counter|finalized|finite|integer/i)
+  })
+
+  it('rejects missing or unexpected validator ID mappings', async () => {
+    await expect(prepareCompletedEpoch(createPreparationInput({
+      validatorIds: new Map([[ADDRESS_A, 11]]),
+    }))).rejects.toThrow(/validator|id|count|address/i)
+
+    await expect(prepareCompletedEpoch(createPreparationInput({
+      validatorIds: new Map([
+        [ADDRESS_A, 11],
+        [ADDRESS_B, 22],
+        [ADDRESS_C, 33],
+      ]),
+    }))).rejects.toThrow(/validator|id|count|address/i)
+  })
+
+  it('rejects invalid or duplicate stored validator IDs', async () => {
+    await expect(prepareCompletedEpoch(createPreparationInput({
+      validatorIds: new Map([
+        [ADDRESS_A, 11],
+        [ADDRESS_B, 11],
+      ]),
+    }))).rejects.toThrow(/duplicate|validator|id/i)
+
+    await expect(prepareCompletedEpoch(createPreparationInput({
+      validatorIds: new Map([
+        [ADDRESS_A, 11],
+        [ADDRESS_B, 0],
+      ]),
+    }))).rejects.toThrow(/validator|id/i)
+  })
+
+  it('rejects election-set epoch and count inconsistencies', async () => {
+    await expect(prepareCompletedEpoch(createPreparationInput({
+      electionSet: { ...createElectionSet(), epochIndex: 76 },
+    }))).rejects.toThrow(/epoch/i)
+
+    const duplicateCanonicalElectionSet = createElectionSet([
+      ADDRESS_A,
+      ADDRESS_A_CANONICAL.toLowerCase(),
+    ])
+    await expect(prepareCompletedEpoch(createPreparationInput({
+      electionSet: duplicateCanonicalElectionSet,
+    }))).rejects.toThrow(/duplicate|count|address/i)
+  })
+})
diff --git a/server/utils/activity-epochs.ts b/server/utils/activity-epochs.ts
new file mode 100644
index 00000000..5d838024
--- /dev/null
+++ b/server/utils/activity-epochs.ts
@@ -0,0 +1,499 @@
+import type { ElectionSet, EpochActivity, Range } from 'nimiq-validator-trustscore/types'
+import type { NewActivity } from './drizzle'
+import { and, eq, gte, lte, sql } from 'drizzle-orm'
+import { ActivityEpochStatus } from '../db/schema'
+import {
+  canonicalizeAddressSet,
+  canonicalizeValidatorAddress,
+  compareCanonicalAddressSets,
+  hashCanonicalAddressSet,
+} from './activity-integrity'
+import { tables, useDrizzle } from './drizzle'
+
+const RECENT_ACTIVITY_DURATION_MS = 14 * 24 * 60 * 60 * 1000
+export const DEFAULT_SYNCING_LEASE_DURATION_MS = 6 * 60 * 60 * 1000
+const DEFAULT_EPOCH_SYNC_LIMIT = 50
+const ACTIVITY_UPSERT_CHUNK_SIZE = 5
+
+export interface ActivityCoverage {
+  fromEpoch: number
+  toEpoch: number
+  expectedEpochCount: number
+  finalizedEpochCount: number
+  coverage: number
+  missingEpochs: number[]
+}
+
+export interface ActivityEpochPlannerMarker {
+  epochNumber: number
+  status: typeof ActivityEpochStatus[keyof typeof ActivityEpochStatus]
+  startedAt: string
+}
+
+export interface ActivityEpochMarker extends ActivityEpochPlannerMarker {
+  finalizedAt: string | null
+  lastError: string | null
+}
+
+export interface PlanEpochSyncInput {
+  range: Pick<Range, 'fromEpoch' | 'toEpoch'>
+  recentRange: Pick<Range, 'fromEpoch' | 'toEpoch'>
+  markers: readonly ActivityEpochPlannerMarker[]
+  now: string | Date
+  limit?: number
+  syncingLeaseDurationMs?: number
+}
+
+export async function getActivityEpochMarkers(
+  range?: Pick<Range, 'fromEpoch' | 'toEpoch'>,
+): Promise<ActivityEpochMarker[]> {
+  const query = useDrizzle().select({
+    epochNumber: tables.activityEpochs.epochNumber,
+    status: tables.activityEpochs.status,
+    startedAt: tables.activityEpochs.startedAt,
+    finalizedAt: tables.activityEpochs.finalizedAt,
+    lastError: tables.activityEpochs.lastError,
+  }).from(tables.activityEpochs)
+
+  if (!range)
+    return query.all()
+
+  return query.where(and(
+    gte(tables.activityEpochs.epochNumber, range.fromEpoch),
+    lte(tables.activityEpochs.epochNumber, range.toEpoch),
+  )).all()
+}
+
+export interface PrepareCompletedEpochInput {
+  epochNumber: number
+  electionSet: ElectionSet
+  activity: EpochActivity
+  validatorIds: ReadonlyMap<string, number>
+}
+
+export interface PreparedCompletedEpoch {
+  epochNumber: number
+  expectedElectedCount: number
+  storedElectedCount: number
+  electedSetHash: string
+  activities: NewActivity[]
+}
+
+export function getRecentEpochRange(range: Range, durationMs = RECENT_ACTIVITY_DURATION_MS): { fromEpoch: number, toEpoch: number } {
+  if (!Number.isFinite(durationMs) || durationMs <= 0)
+    throw new RangeError('Recent activity duration must be positive')
+  if (!Number.isFinite(range.epochDurationMs) || range.epochDurationMs <= 0)
+    throw new RangeError('Epoch duration must be positive')
+
+  const epochCount = Math.max(1, Math.ceil(durationMs / range.epochDurationMs))
+  return {
+    fromEpoch: Math.max(range.fromEpoch, range.toEpoch - epochCount + 1),
+    toEpoch: range.toEpoch,
+  }
+}
+
+export function calculateActivityCoverage(fromEpoch: number, toEpoch: number, finalizedEpochs: readonly number[]): ActivityCoverage {
+  if (!Number.isInteger(fromEpoch) || !Number.isInteger(toEpoch) || fromEpoch > toEpoch)
+    throw new RangeError(`Invalid activity epoch range: ${fromEpoch}-${toEpoch}`)
+
+  const finalizedSet = new Set(finalizedEpochs.filter(epoch => Number.isInteger(epoch) && epoch >= fromEpoch && epoch <= toEpoch))
+  const missingEpochs: number[] = []
+  for (let epochNumber = fromEpoch; epochNumber <= toEpoch; epochNumber++) {
+    if (!finalizedSet.has(epochNumber))
+      missingEpochs.push(epochNumber)
+  }
+
+  const expectedEpochCount = toEpoch - fromEpoch + 1
+  const finalizedEpochCount = finalizedSet.size
+  return {
+    fromEpoch,
+    toEpoch,
+    expectedEpochCount,
+    finalizedEpochCount,
+    coverage: finalizedEpochCount / expectedEpochCount,
+    missingEpochs,
+  }
+}
+
+export function planEpochSync(input: PlanEpochSyncInput): number[] {
+  const nowMs = input.now instanceof Date ? input.now.getTime() : Date.parse(input.now)
+  if (!Number.isFinite(nowMs))
+    throw new Error(`Invalid planner time: ${input.now}`)
+  const syncingLeaseDurationMs = input.syncingLeaseDurationMs ?? DEFAULT_SYNCING_LEASE_DURATION_MS
+  if (!Number.isFinite(syncingLeaseDurationMs) || syncingLeaseDurationMs <= 0)
+    throw new RangeError(`Invalid syncing lease duration: ${syncingLeaseDurationMs}`)
+
+  const markerByEpoch = new Map(input.markers.map(marker => [marker.epochNumber, marker]))
+  const planned = new Set<number>()
+  const ordered: number[] = []
+  const add = (epochNumber: number) => {
+    if (epochNumber < input.range.fromEpoch || epochNumber > input.range.toEpoch || planned.has(epochNumber))
+      return
+    planned.add(epochNumber)
+    ordered.push(epochNumber)
+  }
+  const isStaleSyncing = (marker: ActivityEpochPlannerMarker) => {
+    if (marker.status !== ActivityEpochStatus.Syncing)
+      return false
+    const startedAtMs = Date.parse(marker.startedAt)
+    return !Number.isFinite(startedAtMs) || nowMs - startedAtMs >= syncingLeaseDurationMs
+  }
+  const isFailedOrStale = (marker: ActivityEpochPlannerMarker | undefined) => marker?.status === ActivityEpochStatus.Failed || (marker ? isStaleSyncing(marker) : false)
+  const isEligible = (marker: ActivityEpochPlannerMarker | undefined) => !marker || isFailedOrStale(marker)
+
+  const latestCompleted = input.range.toEpoch
+  if (isEligible(markerByEpoch.get(latestCompleted)))
+    add(latestCompleted)
+
+  const recentFromEpoch = Math.max(input.range.fromEpoch, input.recentRange.fromEpoch)
+  const recentToEpoch = Math.min(input.range.toEpoch, input.recentRange.toEpoch)
+  for (let epochNumber = recentToEpoch; epochNumber >= recentFromEpoch; epochNumber--) {
+    if (isFailedOrStale(markerByEpoch.get(epochNumber)))
+      add(epochNumber)
+  }
+  for (let epochNumber = recentToEpoch; epochNumber >= recentFromEpoch; epochNumber--) {
+    if (!markerByEpoch.has(epochNumber))
+      add(epochNumber)
+  }
+
+  for (let epochNumber = recentFromEpoch - 1; epochNumber >= input.range.fromEpoch; epochNumber--) {
+    if (isFailedOrStale(markerByEpoch.get(epochNumber)))
+      add(epochNumber)
+  }
+  for (let epochNumber = recentFromEpoch - 1; epochNumber >= input.range.fromEpoch; epochNumber--) {
+    if (!markerByEpoch.has(epochNumber))
+      add(epochNumber)
+  }
+
+  const limit = input.limit ?? DEFAULT_EPOCH_SYNC_LIMIT
+  if (!Number.isFinite(limit) && limit !== Infinity)
+    throw new RangeError(`Invalid epoch sync limit: ${limit}`)
+  return ordered.slice(0, Math.max(0, Math.floor(limit)))
+}
+
+function isNonNegativeInteger(value: number): boolean {
+  return Number.isInteger(value) && value >= 0
+}
+
+export async function prepareCompletedEpoch(input: PrepareCompletedEpochInput): Promise<PreparedCompletedEpoch> {
+  if (!Number.isInteger(input.epochNumber) || input.epochNumber < 1)
+    throw new Error(`Invalid completed epoch number: ${input.epochNumber}`)
+  if (input.electionSet.epochIndex !== input.epochNumber)
+    throw new Error(`Election set epoch ${input.electionSet.epochIndex} does not match completed epoch ${input.epochNumber}`)
+
+  const electionAddresses = input.electionSet.validators.map(validator => validator.address)
+  const activityAddresses = Object.keys(input.activity)
+  const validatorIdAddresses = Array.from(input.validatorIds.keys())
+  const activityComparison = compareCanonicalAddressSets(electionAddresses, activityAddresses)
+  if (!activityComparison.matches)
+    throw new Error(`Election and activity address sets do not match: ${JSON.stringify(activityComparison)}`)
+  const validatorIdComparison = compareCanonicalAddressSets(electionAddresses, validatorIdAddresses)
+  if (!validatorIdComparison.matches)
+    throw new Error(`Election and validator ID address sets do not match: ${JSON.stringify(validatorIdComparison)}`)
+
+  const expectedElectedCount = electionAddresses.length
+  if (activityAddresses.length !== expectedElectedCount || input.validatorIds.size !== expectedElectedCount)
+    throw new Error(`Completed epoch count mismatch: expected ${expectedElectedCount}, activity ${activityAddresses.length}, validator IDs ${input.validatorIds.size}`)
+
+  const activityByCanonicalAddress = new Map<string, EpochActivity[string]>()
+  for (const [address, activity] of Object.entries(input.activity)) {
+    const canonicalAddress = canonicalizeValidatorAddress(address)
+    if (canonicalizeValidatorAddress(activity.address) !== canonicalAddress)
+      throw new Error(`Activity payload address does not match key: ${address}`)
+    if (!activity.elected)
+      throw new Error(`Completed epoch activity must be elected: ${address}`)
+    if (!isNonNegativeInteger(activity.missed) || !isNonNegativeInteger(activity.rewarded))
+      throw new Error(`Completed epoch activity counters must be finalized non-negative integers: ${address}`)
+    activityByCanonicalAddress.set(canonicalAddress, activity)
+  }
+
+  const validatorIdByCanonicalAddress = new Map<string, number>()
+  const storedValidatorIds = new Set<number>()
+  for (const [address, validatorId] of input.validatorIds) {
+    if (!Number.isInteger(validatorId) || validatorId < 1)
+      throw new Error(`Invalid stored validator ID for ${address}: ${validatorId}`)
+    if (storedValidatorIds.has(validatorId))
+      throw new Error(`Duplicate stored validator ID: ${validatorId}`)
+    storedValidatorIds.add(validatorId)
+    validatorIdByCanonicalAddress.set(canonicalizeValidatorAddress(address), validatorId)
+  }
+
+  const electionValidatorByCanonicalAddress = new Map(input.electionSet.validators.map(validator => [
+    canonicalizeValidatorAddress(validator.address),
+    validator,
+  ]))
+  const activities = canonicalizeAddressSet(electionAddresses).map((canonicalAddress): NewActivity => {
+    const activity = activityByCanonicalAddress.get(canonicalAddress)
+    const validatorId = validatorIdByCanonicalAddress.get(canonicalAddress)
+    const electionValidator = electionValidatorByCanonicalAddress.get(canonicalAddress)
+    if (!activity || !validatorId || !electionValidator)
+      throw new Error(`Missing prepared completed epoch data for ${canonicalAddress}`)
+    if (activity.likelihood !== electionValidator.numSlots)
+      throw new Error(`Election slots and activity likelihood do not match for ${canonicalAddress}`)
+
+    return {
+      validatorId,
+      epochNumber: input.epochNumber,
+      likelihood: activity.likelihood,
+      rewarded: activity.rewarded,
+      missed: activity.missed,
+      dominanceRatioViaBalance: activity.dominanceRatioViaBalance,
+      dominanceRatioViaSlots: activity.dominanceRatioViaSlots,
+      balance: activity.balance,
+      stakers: activity.stakers,
+    }
+  })
+
+  return {
+    epochNumber: input.epochNumber,
+    expectedElectedCount,
+    storedElectedCount: activities.length,
+    electedSetHash: await hashCanonicalAddressSet(electionAddresses),
+    activities,
+  }
+}
+
+export async function beginActivityEpochAttempt(epochNumber: number, startedAt: string): Promise<boolean> {
+  const claimed = await useDrizzle().insert(tables.activityEpochs).values({
+    epochNumber,
+    status: ActivityEpochStatus.Syncing,
+    attemptCount: 1,
+    startedAt,
+    expectedElectedCount: null,
+    storedElectedCount: null,
+    electedSetHash: null,
+    finalizedAt: null,
+    lastError: null,
+  }).onConflictDoUpdate({
+    target: tables.activityEpochs.epochNumber,
+    set: {
+      status: ActivityEpochStatus.Syncing,
+      attemptCount: sql`${tables.activityEpochs.attemptCount} + 1`,
+      startedAt,
+      expectedElectedCount: null,
+      storedElectedCount: null,
+      electedSetHash: null,
+      finalizedAt: null,
+      lastError: null,
+    },
+    setWhere: sql`${tables.activityEpochs.status} != ${ActivityEpochStatus.Finalized}`,
+  }).returning({
+    status: tables.activityEpochs.status,
+    startedAt: tables.activityEpochs.startedAt,
+  }).get()
+
+  return claimed !== undefined
+    && claimed.status === ActivityEpochStatus.Syncing
+    && claimed.startedAt === startedAt
+}
+
+function formatActivityEpochError(error: unknown): string {
+  if (error instanceof Error)
+    return error.message || error.name
+  if (typeof error === 'string')
+    return error
+  try {
+    return JSON.stringify(error) || String(error)
+  }
+  catch {
+    return String(error)
+  }
+}
+
+export async function markActivityEpochFailed(epochNumber: number, error: unknown, startedAt?: string): Promise<void> {
+  const ownershipConditions = [
+    eq(tables.activityEpochs.epochNumber, epochNumber),
+    eq(tables.activityEpochs.status, ActivityEpochStatus.Syncing),
+  ]
+  if (startedAt)
+    ownershipConditions.push(eq(tables.activityEpochs.startedAt, startedAt))
+
+  await useDrizzle().update(tables.activityEpochs).set({
+    status: ActivityEpochStatus.Failed,
+    finalizedAt: null,
+    lastError: formatActivityEpochError(error),
+  }).where(and(...ownershipConditions)).execute()
+}
+
+export async function persistCompletedEpoch(prepared: PreparedCompletedEpoch, startedAt: string, finalizedAt: string): Promise<void> {
+  if (!isNonNegativeInteger(prepared.expectedElectedCount)
+    || !isNonNegativeInteger(prepared.storedElectedCount)
+    || prepared.expectedElectedCount !== prepared.storedElectedCount
+    || prepared.activities.length !== prepared.storedElectedCount) {
+    throw new Error('Prepared completed epoch counts must be matching non-negative integers')
+  }
+  if (prepared.activities.some(activity => !isNonNegativeInteger(activity.rewarded) || !isNonNegativeInteger(activity.missed)))
+    throw new Error('Prepared completed epoch activity counters must be non-negative integers')
+
+  const db = useDrizzle()
+  const currentAttempt = await db.select({
+    status: tables.activityEpochs.status,
+    startedAt: tables.activityEpochs.startedAt,
+  }).from(tables.activityEpochs).where(eq(tables.activityEpochs.epochNumber, prepared.epochNumber)).get()
+  if (currentAttempt && (
+    currentAttempt.startedAt !== startedAt
+    || (currentAttempt.status !== ActivityEpochStatus.Syncing && currentAttempt.status !== ActivityEpochStatus.Finalized)
+  )) {
+    throw new Error(`Stale activity epoch attempt cannot finalize epoch ${prepared.epochNumber}`)
+  }
+
+  // A mismatched owner resolves startedAt to NULL, forcing the whole batch to roll back.
+  const markerStatement = db.insert(tables.activityEpochs).values({
+    epochNumber: prepared.epochNumber,
+    status: ActivityEpochStatus.Syncing,
+    expectedElectedCount: prepared.expectedElectedCount,
+    storedElectedCount: prepared.storedElectedCount,
+    electedSetHash: prepared.electedSetHash,
+    attemptCount: 1,
+    startedAt,
+    finalizedAt: null,
+    lastError: null,
+  }).onConflictDoUpdate({
+    target: tables.activityEpochs.epochNumber,
+    set: {
+      status: ActivityEpochStatus.Syncing,
+      expectedElectedCount: prepared.expectedElectedCount,
+      storedElectedCount: prepared.storedElectedCount,
+      electedSetHash: prepared.electedSetHash,
+      startedAt: sql`CASE
+        WHEN ${tables.activityEpochs.startedAt} = ${startedAt}
+          AND ${tables.activityEpochs.status} IN (${ActivityEpochStatus.Syncing}, ${ActivityEpochStatus.Finalized})
+        THEN ${startedAt}
+        ELSE NULL
+      END`,
+      finalizedAt: null,
+      lastError: null,
+    },
+  })
+  const expectedValidatorIds = [...new Set(prepared.activities.map(activity => activity.validatorId))]
+  // IDs come from validated stored-validator rows; literals avoid D1 bind limits for large election sets.
+  const deleteStaleStatement = expectedValidatorIds.length === 0
+    ? db.delete(tables.activity).where(eq(tables.activity.epochNumber, prepared.epochNumber))
+    : db.delete(tables.activity).where(and(
+        eq(tables.activity.epochNumber, prepared.epochNumber),
+        sql`${tables.activity.validatorId} NOT IN (${sql.raw(expectedValidatorIds.join(', '))})`,
+      ))
+  const activityStatements = Array.from(
+    { length: Math.ceil(prepared.activities.length / ACTIVITY_UPSERT_CHUNK_SIZE) },
+    (_, chunkIndex) => {
+      const fromIndex = chunkIndex * ACTIVITY_UPSERT_CHUNK_SIZE
+      const activityChunk = prepared.activities.slice(fromIndex, fromIndex + ACTIVITY_UPSERT_CHUNK_SIZE)
+      return db.insert(tables.activity).values(activityChunk).onConflictDoUpdate({
+        target: [tables.activity.validatorId, tables.activity.epochNumber],
+        set: {
+          likelihood: sql`excluded.likelihood`,
+          rewarded: sql`excluded.rewarded`,
+          missed: sql`excluded.missed`,
+          dominanceRatioViaBalance: sql`CASE WHEN ${tables.activity.dominanceRatioViaBalance} != -1 THEN ${tables.activity.dominanceRatioViaBalance} ELSE excluded.dominance_ratio_via_balance END`,
+          dominanceRatioViaSlots: sql`CASE WHEN ${tables.activity.dominanceRatioViaSlots} != -1 THEN ${tables.activity.dominanceRatioViaSlots} ELSE excluded.dominance_ratio_via_slots END`,
+          balance: sql`CASE WHEN excluded.balance >= 0 THEN excluded.balance ELSE ${tables.activity.balance} END`,
+          stakers: sql`CASE WHEN excluded.balance >= 0 OR excluded.stakers > 0 THEN excluded.stakers ELSE ${tables.activity.stakers} END`,
+        },
+      })
+    },
+  )
+  const finalizeStatement = db.update(tables.activityEpochs).set({
+    status: ActivityEpochStatus.Finalized,
+    expectedElectedCount: prepared.expectedElectedCount,
+    storedElectedCount: prepared.storedElectedCount,
+    electedSetHash: prepared.electedSetHash,
+    finalizedAt,
+    lastError: null,
+  }).where(and(
+    eq(tables.activityEpochs.epochNumber, prepared.epochNumber),
+    eq(tables.activityEpochs.status, ActivityEpochStatus.Syncing),
+    eq(tables.activityEpochs.startedAt, startedAt),
+  ))
+
+  await db.batch([
+    markerStatement,
+    deleteStaleStatement,
+    ...activityStatements,
+    finalizeStatement,
+  ])
+}
+
+export async function finalizeVerifiedCompletedEpoch(
+  epochNumber: number,
+  electionSet: ElectionSet,
+  validatorIds: ReadonlyMap<string, number>,
+  startedAt: string,
+  finalizedAt: string,
+): Promise<void> {
+  if (electionSet.epochIndex !== epochNumber)
+    throw new Error(`Election set epoch ${electionSet.epochIndex} does not match completed epoch ${epochNumber}`)
+
+  const electionAddresses = electionSet.validators.map(validator => validator.address)
+  const validatorIdAddresses = Array.from(validatorIds.keys())
+  const validatorIdComparison = compareCanonicalAddressSets(electionAddresses, validatorIdAddresses)
+  if (!validatorIdComparison.matches)
+    throw new Error(`Election and validator ID address sets do not match: ${JSON.stringify(validatorIdComparison)}`)
+
+  const expectedValidatorIds = [...new Set(validatorIds.values())]
+  if (expectedValidatorIds.length !== electionAddresses.length
+    || expectedValidatorIds.some(validatorId => !Number.isInteger(validatorId) || validatorId < 1)) {
+    throw new Error('Verified completed epoch validator IDs must be unique positive integers')
+  }
+
+  const expectedElectedCount = electionAddresses.length
+  const electedSetHash = await hashCanonicalAddressSet(electionAddresses)
+  const db = useDrizzle()
+  const currentAttempt = await db.select({
+    status: tables.activityEpochs.status,
+    startedAt: tables.activityEpochs.startedAt,
+  }).from(tables.activityEpochs).where(eq(tables.activityEpochs.epochNumber, epochNumber)).get()
+  if (currentAttempt && (
+    currentAttempt.startedAt !== startedAt
+    || (currentAttempt.status !== ActivityEpochStatus.Syncing && currentAttempt.status !== ActivityEpochStatus.Finalized)
+  )) {
+    throw new Error(`Stale activity epoch attempt cannot finalize epoch ${epochNumber}`)
+  }
+
+  const markerStatement = db.insert(tables.activityEpochs).values({
+    epochNumber,
+    status: ActivityEpochStatus.Syncing,
+    expectedElectedCount,
+    storedElectedCount: expectedElectedCount,
+    electedSetHash,
+    attemptCount: 1,
+    startedAt,
+    finalizedAt: null,
+    lastError: null,
+  }).onConflictDoUpdate({
+    target: tables.activityEpochs.epochNumber,
+    set: {
+      status: ActivityEpochStatus.Syncing,
+      expectedElectedCount,
+      storedElectedCount: expectedElectedCount,
+      electedSetHash,
+      startedAt: sql`CASE
+        WHEN ${tables.activityEpochs.startedAt} = ${startedAt}
+          AND ${tables.activityEpochs.status} IN (${ActivityEpochStatus.Syncing}, ${ActivityEpochStatus.Finalized})
+        THEN ${startedAt}
+        ELSE NULL
+      END`,
+      finalizedAt: null,
+      lastError: null,
+    },
+  })
+  const deleteSnapshotRows = expectedValidatorIds.length === 0
+    ? db.delete(tables.activity).where(eq(tables.activity.epochNumber, epochNumber))
+    : db.delete(tables.activity).where(and(
+        eq(tables.activity.epochNumber, epochNumber),
+        sql`${tables.activity.validatorId} NOT IN (${sql.raw(expectedValidatorIds.join(', '))})`,
+      ))
+  const finalizeStatement = db.update(tables.activityEpochs).set({
+    status: ActivityEpochStatus.Finalized,
+    expectedElectedCount,
+    storedElectedCount: expectedElectedCount,
+    electedSetHash,
+    finalizedAt,
+    lastError: null,
+  }).where(and(
+    eq(tables.activityEpochs.epochNumber, epochNumber),
+    eq(tables.activityEpochs.status, ActivityEpochStatus.Syncing),
+    eq(tables.activityEpochs.startedAt, startedAt),
+  ))
+
+  await db.batch([markerStatement, deleteSnapshotRows, finalizeStatement])
+}
diff --git a/server/utils/activity-integrity.test.ts b/server/utils/activity-integrity.test.ts
new file mode 100644
index 00000000..87ae518b
--- /dev/null
+++ b/server/utils/activity-integrity.test.ts
@@ -0,0 +1,83 @@
+import { describe, expect, it } from 'vitest'
+import {
+  canonicalizeAddressSet,
+  canonicalizeValidatorAddress,
+  compareCanonicalAddressSets,
+  hashCanonicalAddressSet,
+} from './activity-integrity'
+
+const ADDRESS_A = 'NQ02 31N6 3KM5 T6G5 22TN EPF5 5XPY RLHK RMB3'
+const ADDRESS_A_CANONICAL = 'NQ0231N63KM5T6G522TNEPF55XPYRLHKRMB3'
+const ADDRESS_B = 'NQ29 FBVT B4GM S27H UBP4 1MTC GNKQ VPBT 099M'
+const ADDRESS_B_CANONICAL = 'NQ29FBVTB4GMS27HUBP41MTCGNKQVPBT099M'
+const ADDRESS_C = 'NQ40 FC4D HAT6 9N1H P52H P4FX QL8P CE6Y 10VT'
+const ADDRESS_C_CANONICAL = 'NQ40FC4DHAT69N1HP52HP4FXQL8PCE6Y10VT'
+
+describe('activity integrity address sets', () => {
+  it('canonicalizes validator identity by removing whitespace and uppercasing', () => {
+    expect(canonicalizeValidatorAddress('  nq02\t31n6 3km5\n t6g5 22tn epf5 5xpy rlhk rmb3  '))
+      .toBe(ADDRESS_A_CANONICAL)
+  })
+
+  it('returns a deterministically sorted canonical set without mutating the input', () => {
+    const addresses = [ADDRESS_C, ADDRESS_A.toLowerCase(), ADDRESS_B]
+
+    expect(canonicalizeAddressSet(addresses)).toEqual([
+      ADDRESS_A_CANONICAL,
+      ADDRESS_B_CANONICAL,
+      ADDRESS_C_CANONICAL,
+    ])
+    expect(addresses).toEqual([ADDRESS_C, ADDRESS_A.toLowerCase(), ADDRESS_B])
+  })
+
+  it('rejects duplicate canonical identities', () => {
+    expect(() => canonicalizeAddressSet([
+      ADDRESS_A,
+      ` ${ADDRESS_A_CANONICAL.toLowerCase()} `,
+    ])).toThrow(/duplicate/i)
+  })
+
+  it('compares exact membership independently of formatting and order', () => {
+    expect(compareCanonicalAddressSets(
+      [ADDRESS_A, ADDRESS_B],
+      [ADDRESS_B.toLowerCase(), ADDRESS_A_CANONICAL],
+    )).toEqual({ matches: true, missing: [], unexpected: [] })
+  })
+
+  it('reports sorted missing and unexpected canonical identities', () => {
+    expect(compareCanonicalAddressSets(
+      [ADDRESS_B, ADDRESS_A],
+      [ADDRESS_C.toLowerCase(), ADDRESS_B_CANONICAL],
+    )).toEqual({
+      matches: false,
+      missing: [ADDRESS_A_CANONICAL],
+      unexpected: [ADDRESS_C_CANONICAL],
+    })
+  })
+
+  it('rejects duplicates instead of hiding them during comparison', () => {
+    expect(() => compareCanonicalAddressSets(
+      [ADDRESS_A, ADDRESS_A_CANONICAL.toLowerCase()],
+      [ADDRESS_A],
+    )).toThrow(/duplicate/i)
+  })
+
+  it('produces a stable SHA-256 hash for equivalent canonical sets', async () => {
+    const hash = await hashCanonicalAddressSet([ADDRESS_C, ADDRESS_A, ADDRESS_B])
+
+    expect(hash).toMatch(/^[a-f\d]{64}$/)
+    await expect(hashCanonicalAddressSet([
+      ADDRESS_B_CANONICAL.toLowerCase(),
+      ADDRESS_C.toLowerCase(),
+      ADDRESS_A_CANONICAL,
+    ])).resolves.toBe(hash)
+    await expect(hashCanonicalAddressSet([ADDRESS_A, ADDRESS_B])).resolves.not.toBe(hash)
+  })
+
+  it('rejects duplicates before hashing', async () => {
+    await expect(hashCanonicalAddressSet([
+      ADDRESS_A,
+      ADDRESS_A_CANONICAL.toLowerCase(),
+    ])).rejects.toThrow(/duplicate/i)
+  })
+})
diff --git a/server/utils/activity-integrity.ts b/server/utils/activity-integrity.ts
new file mode 100644
index 00000000..3c0f43d3
--- /dev/null
+++ b/server/utils/activity-integrity.ts
@@ -0,0 +1,43 @@
+export function canonicalizeValidatorAddress(address: string): string {
+  return address.replace(/\s/g, '').toUpperCase()
+}
+
+export function canonicalizeAddressSet(addresses: readonly string[]): string[] {
+  const canonicalAddresses = addresses.map(canonicalizeValidatorAddress)
+  const seenAddresses = new Set<string>()
+
+  for (const address of canonicalAddresses) {
+    if (seenAddresses.has(address))
+      throw new Error(`Duplicate validator address: ${address}`)
+    seenAddresses.add(address)
+  }
+
+  return canonicalAddresses.sort()
+}
+
+export function compareCanonicalAddressSets(expected: readonly string[], actual: readonly string[]): {
+  matches: boolean
+  missing: string[]
+  unexpected: string[]
+} {
+  const canonicalExpected = canonicalizeAddressSet(expected)
+  const canonicalActual = canonicalizeAddressSet(actual)
+  const expectedSet = new Set(canonicalExpected)
+  const actualSet = new Set(canonicalActual)
+  const missing = canonicalExpected.filter(address => !actualSet.has(address))
+  const unexpected = canonicalActual.filter(address => !expectedSet.has(address))
+
+  return {
+    matches: missing.length === 0 && unexpected.length === 0,
+    missing,
+    unexpected,
+  }
+}
+
+export async function hashCanonicalAddressSet(addresses: readonly string[]): Promise<string> {
+  const canonicalAddresses = canonicalizeAddressSet(addresses)
+  const encodedAddresses = new TextEncoder().encode(canonicalAddresses.join('\n'))
+  const digest = await globalThis.crypto.subtle.digest('SHA-256', encodedAddresses)
+
+  return Array.from(new Uint8Array(digest), byte => byte.toString(16).padStart(2, '0')).join('')
+}
diff --git a/server/utils/activity-persistence.integration.test.ts b/server/utils/activity-persistence.integration.test.ts
new file mode 100644
index 00000000..8266ae0e
--- /dev/null
+++ b/server/utils/activity-persistence.integration.test.ts
@@ -0,0 +1,1108 @@
+import type { EpochActivity, Range } from 'nimiq-validator-trustscore/types'
+import type { TestDbHarness } from '../test/db-harness'
+import { and, asc, eq } from 'drizzle-orm'
+import { afterAll, afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import * as schema from '../db/schema'
+import { createTestDbHarness } from '../test/db-harness'
+
+const ADDRESS_A = 'NQ02 31N6 3KM5 T6G5 22TN EPF5 5XPY RLHK RMB3'
+const ADDRESS_B = 'NQ29 FBVT B4GM S27H UBP4 1MTC GNKQ VPBT 099M'
+const ADDRESS_C = 'NQ40 FC4D HAT6 9N1H P52H P4FX QL8P CE6Y 10VT'
+const ADDRESS_D = 'NQ11 1111 1111 1111 1111 1111 1111 1111 1111'
+const ADDRESS_SHARED = 'NQ22 2222 2222 2222 2222 2222 2222 2222 2222'
+const STARTED_AT = '2026-07-28T08:00:00.000Z'
+const FINALIZED_AT = '2026-07-28T08:05:00.000Z'
+
+const drizzleState = vi.hoisted(() => ({ db: undefined as unknown }))
+const fetcherMocks = vi.hoisted(() => ({
+  fetchSnapshotEpoch: vi.fn(),
+}))
+const logoBarrierState = vi.hoisted(() => ({
+  address: undefined as string | undefined,
+  expectedArrivals: 0,
+  arrivals: 0,
+  gate: undefined as Promise<void> | undefined,
+  release: undefined as (() => void) | undefined,
+  firstArrival: undefined as Promise<void> | undefined,
+  signalFirstArrival: undefined as (() => void) | undefined,
+  allArrived: undefined as Promise<void> | undefined,
+  signalAllArrived: undefined as (() => void) | undefined,
+}))
+
+vi.mock('./drizzle', async () => {
+  const [tables, drizzleOrm] = await Promise.all([
+    import('../db/schema'),
+    import('drizzle-orm'),
+  ])
+
+  return {
+    ...drizzleOrm,
+    tables,
+    useDrizzle: () => drizzleState.db,
+  }
+})
+
+vi.mock('./logo', () => ({
+  handleValidatorLogo: async (address: string) => {
+    if (address === logoBarrierState.address && logoBarrierState.gate) {
+      logoBarrierState.arrivals++
+      logoBarrierState.signalFirstArrival?.()
+      if (logoBarrierState.arrivals >= logoBarrierState.expectedArrivals)
+        logoBarrierState.signalAllArrived?.()
+      await logoBarrierState.gate
+    }
+    return {
+      logo: 'test-logo',
+      hasDefaultLogo: true,
+      accentColor: '#000000',
+    }
+  },
+}))
+
+vi.mock('../../packages/nimiq-validator-trustscore/src/fetcher', () => ({
+  fetchSnapshotEpoch: fetcherMocks.fetchSnapshotEpoch,
+}))
+
+vi.stubGlobal('tables', schema)
+vi.stubGlobal('useDrizzle', () => drizzleState.db)
+vi.stubGlobal('defineCachedFunction', (fn: unknown) => fn)
+vi.stubGlobal('createError', (message: unknown) => new Error(String(message)))
+vi.stubGlobal('useSafeRuntimeConfig', () => ({ public: { nimiqNetwork: 'testnet' } }))
+
+type ActivityEpochModule = typeof import('./activity-epochs')
+type ActivitiesModule = typeof import('./activities')
+type ValidatorsModule = typeof import('./validators')
+
+let activityEpochs: ActivityEpochModule
+let activities: ActivitiesModule
+let validators: ValidatorsModule
+let harness: TestDbHarness
+
+beforeEach(async () => {
+  harness = await createTestDbHarness()
+  drizzleState.db = harness.db
+  fetcherMocks.fetchSnapshotEpoch.mockReset()
+  logoBarrierState.address = undefined
+  logoBarrierState.expectedArrivals = 0
+  logoBarrierState.arrivals = 0
+  logoBarrierState.gate = undefined
+  logoBarrierState.release = undefined
+  logoBarrierState.firstArrival = undefined
+  logoBarrierState.signalFirstArrival = undefined
+  logoBarrierState.allArrived = undefined
+  logoBarrierState.signalAllArrived = undefined
+  vi.resetModules()
+  activityEpochs = await import('./activity-epochs')
+  activities = await import('./activities')
+  validators = await import('./validators')
+})
+
+afterEach(() => {
+  harness.close()
+  drizzleState.db = undefined
+})
+
+afterAll(() => {
+  vi.unstubAllGlobals()
+})
+
+async function insertValidator(address: string) {
+  return harness.db.insert(schema.validators).values({
+    address,
+    name: 'Test validator',
+    logo: 'test-logo',
+    hasDefaultLogo: true,
+    accentColor: '#000000',
+  }).returning({ id: schema.validators.id }).get()
+}
+
+function createElectedActivity(address: string, likelihood: number, rewarded = 718): EpochActivity[string] {
+  return {
+    address,
+    elected: true,
+    likelihood,
+    missed: 2,
+    rewarded,
+    dominanceRatioViaBalance: -1,
+    dominanceRatioViaSlots: likelihood / 512,
+    balance: -1,
+    stakers: 0,
+  }
+}
+
+async function prepareEpoch(epochNumber: number, validatorIds: Map<string, number>) {
+  const activity: EpochActivity = {
+    [ADDRESS_B]: createElectedActivity(ADDRESS_B, 11),
+    [ADDRESS_A]: createElectedActivity(ADDRESS_A, 10),
+  }
+
+  return activityEpochs.prepareCompletedEpoch({
+    epochNumber,
+    electionSet: {
+      epochIndex: epochNumber,
+      electionBlockNumber: 123_456,
+      validators: [
+        { address: ADDRESS_A, numSlots: 10 },
+        { address: ADDRESS_B, numSlots: 11 },
+      ],
+    },
+    activity,
+    validatorIds,
+  })
+}
+
+function armLogoBarrier(address: string, expectedArrivals: number) {
+  logoBarrierState.address = address
+  logoBarrierState.expectedArrivals = expectedArrivals
+  logoBarrierState.gate = new Promise<void>((resolve) => {
+    logoBarrierState.release = resolve
+  })
+  logoBarrierState.firstArrival = new Promise<void>((resolve) => {
+    logoBarrierState.signalFirstArrival = resolve
+  })
+  logoBarrierState.allArrived = new Promise<void>((resolve) => {
+    logoBarrierState.signalAllArrived = resolve
+  })
+}
+
+function createRange(fromEpoch: number, toEpoch: number): Range {
+  return {
+    head: 1_000_000,
+    headEpoch: toEpoch + 1,
+    epochCount: toEpoch - fromEpoch + 1,
+    epochDurationMs: 12 * 60 * 60 * 1000,
+    fromEpoch,
+    fromBlockNumber: 0,
+    fromTimestamp: 0,
+    toEpoch,
+    toBlockNumber: 999_999,
+    toTimestamp: 0,
+    snapshotEpoch: toEpoch + 1,
+    snapshotBlock: 1_000_000,
+    snapshotTimestamp: 0,
+  }
+}
+
+describe('activity epoch attempt markers', () => {
+  it('records failed attempts and clears failure state when a new attempt begins', async () => {
+    await activityEpochs.beginActivityEpochAttempt(77, STARTED_AT)
+    await activityEpochs.markActivityEpochFailed(77, new Error('RPC batch exploded'))
+
+    expect(await harness.db.select().from(schema.activityEpochs).where(eq(schema.activityEpochs.epochNumber, 77)).get())
+      .toMatchObject({
+        epochNumber: 77,
+        status: 'failed',
+        attemptCount: 1,
+        startedAt: STARTED_AT,
+        finalizedAt: null,
+        lastError: expect.stringContaining('RPC batch exploded'),
+      })
+
+    const retryStartedAt = '2026-07-28T14:00:00.000Z'
+    await activityEpochs.beginActivityEpochAttempt(77, retryStartedAt)
+
+    expect(await harness.db.select().from(schema.activityEpochs).where(eq(schema.activityEpochs.epochNumber, 77)).get())
+      .toMatchObject({
+        status: 'syncing',
+        attemptCount: 2,
+        startedAt: retryStartedAt,
+        finalizedAt: null,
+        lastError: null,
+      })
+  })
+
+  it('does not let a stale attempt mark a newer syncing attempt failed', async () => {
+    const epochNumber = 78
+    const newerStartedAt = '2026-07-28T14:00:00.000Z'
+    await activityEpochs.beginActivityEpochAttempt(epochNumber, STARTED_AT)
+    await activityEpochs.beginActivityEpochAttempt(epochNumber, newerStartedAt)
+
+    await activityEpochs.markActivityEpochFailed(epochNumber, new Error('late stale failure'), STARTED_AT)
+
+    expect(await harness.db.select().from(schema.activityEpochs).where(eq(schema.activityEpochs.epochNumber, epochNumber)).get())
+      .toMatchObject({
+        status: 'syncing',
+        attemptCount: 2,
+        startedAt: newerStartedAt,
+        finalizedAt: null,
+        lastError: null,
+      })
+  })
+
+  it('does not let a stale attempt finalize activity or overwrite a newer syncing attempt', async () => {
+    const validatorA = await insertValidator(ADDRESS_A)
+    const validatorB = await insertValidator(ADDRESS_B)
+    const epochNumber = 79
+    const newerStartedAt = '2026-07-28T14:00:00.000Z'
+    const prepared = await prepareEpoch(epochNumber, new Map([
+      [ADDRESS_A, validatorA.id],
+      [ADDRESS_B, validatorB.id],
+    ]))
+    await activityEpochs.beginActivityEpochAttempt(epochNumber, STARTED_AT)
+    await activityEpochs.beginActivityEpochAttempt(epochNumber, newerStartedAt)
+
+    await expect(activityEpochs.persistCompletedEpoch(prepared, STARTED_AT, FINALIZED_AT))
+      .rejects
+      .toThrow(/attempt|ownership|stale/i)
+
+    expect(await harness.db.select().from(schema.activity).where(eq(schema.activity.epochNumber, epochNumber)).all()).toEqual([])
+    expect(await harness.db.select().from(schema.activityEpochs).where(eq(schema.activityEpochs.epochNumber, epochNumber)).get())
+      .toMatchObject({
+        status: 'syncing',
+        attemptCount: 2,
+        startedAt: newerStartedAt,
+        expectedElectedCount: null,
+        storedElectedCount: null,
+        finalizedAt: null,
+        lastError: null,
+      })
+  })
+
+  it('does not let a delayed attempt reopen or invalidate an already finalized epoch', async () => {
+    const validatorA = await insertValidator(ADDRESS_A)
+    const validatorB = await insertValidator(ADDRESS_B)
+    const epochNumber = 86
+    const prepared = await prepareEpoch(epochNumber, new Map([
+      [ADDRESS_A, validatorA.id],
+      [ADDRESS_B, validatorB.id],
+    ]))
+    await activityEpochs.beginActivityEpochAttempt(epochNumber, STARTED_AT)
+    await activityEpochs.persistCompletedEpoch(prepared, STARTED_AT, FINALIZED_AT)
+    const finalizedActivity = await harness.db.select().from(schema.activity).where(eq(schema.activity.epochNumber, epochNumber)).orderBy(asc(schema.activity.validatorId)).all()
+
+    const delayedStartedAt = '2026-07-28T16:00:00.000Z'
+    await expect(activityEpochs.beginActivityEpochAttempt(epochNumber, delayedStartedAt)).resolves.toBe(false)
+    await activityEpochs.markActivityEpochFailed(epochNumber, new Error('late worker failure'), delayedStartedAt)
+
+    expect(await harness.db.select().from(schema.activityEpochs).where(eq(schema.activityEpochs.epochNumber, epochNumber)).get())
+      .toMatchObject({
+        status: 'finalized',
+        attemptCount: 1,
+        startedAt: STARTED_AT,
+        finalizedAt: FINALIZED_AT,
+        lastError: null,
+      })
+    expect(await harness.db.select().from(schema.activity).where(eq(schema.activity.epochNumber, epochNumber)).orderBy(asc(schema.activity.validatorId)).all()).toEqual(finalizedActivity)
+  })
+})
+
+describe('strict validator resolution and cache behavior', () => {
+  it('does not cache an undefined ID after a tolerated insert failure', async () => {
+    await harness.execute(`
+      CREATE TRIGGER fail_tolerant_validator_insert
+      BEFORE INSERT ON validators
+      WHEN NEW.address = '${ADDRESS_A}'
+      BEGIN
+        SELECT RAISE(ABORT, 'forced tolerant validator failure');
+      END
+    `)
+
+    await expect(validators.storeValidator(ADDRESS_A)).resolves.toBeUndefined()
+    await harness.execute('DROP TRIGGER fail_tolerant_validator_insert')
+
+    const retriedId = await validators.storeValidator(ADDRESS_A)
+
+    expect(retriedId).toEqual(expect.any(Number))
+    expect(await harness.db.select({ address: schema.validators.address }).from(schema.validators).all())
+      .toEqual([{ address: ADDRESS_A }])
+  })
+
+  it('throws on strict resolution failure without writing marker or activity state', async () => {
+    await harness.execute(`
+      CREATE TRIGGER fail_strict_validator_insert
+      BEFORE INSERT ON validators
+      WHEN NEW.address = '${ADDRESS_B}'
+      BEGIN
+        SELECT RAISE(ABORT, 'forced strict validator failure');
+      END
+    `)
+
+    const strictError = await validators.storeValidatorStrict(ADDRESS_B).then(
+      () => undefined,
+      error => error,
+    )
+
+    expect(strictError).toBeInstanceOf(Error)
+    expect(String(strictError)).toMatch(/validator|strict|database|sqlite|constraint|forced/i)
+    expect(await harness.db.select().from(schema.validators).all()).toEqual([])
+    expect(await harness.db.select().from(schema.activity).all()).toEqual([])
+    expect(await harness.db.select().from(schema.activityEpochs).all()).toEqual([])
+
+    await harness.execute('DROP TRIGGER fail_strict_validator_insert')
+    await expect(validators.storeValidatorStrict(ADDRESS_B)).resolves.toEqual(expect.any(Number))
+  })
+})
+
+describe('atomic completed epoch persistence', () => {
+  it.each([
+    ['expectedElectedCount', 0.5],
+    ['expectedElectedCount', Number.NaN],
+    ['expectedElectedCount', Number.POSITIVE_INFINITY],
+    ['storedElectedCount', 0.5],
+    ['storedElectedCount', Number.NaN],
+    ['storedElectedCount', Number.POSITIVE_INFINITY],
+  ] as const)('rejects an invalid finalized %s value: %s', async (counter, invalidCount) => {
+    const validatorA = await insertValidator(ADDRESS_A)
+    const validatorB = await insertValidator(ADDRESS_B)
+    const prepared = await prepareEpoch(76, new Map([
+      [ADDRESS_A, validatorA.id],
+      [ADDRESS_B, validatorB.id],
+    ]))
+    const invalidPrepared = {
+      ...prepared,
+      [counter]: invalidCount,
+    }
+
+    await expect(activityEpochs.persistCompletedEpoch(invalidPrepared, STARTED_AT, FINALIZED_AT))
+      .rejects
+      .toThrow(/count|finite|integer/i)
+    expect(await harness.db.select().from(schema.activity).all()).toEqual([])
+    expect(await harness.db.select().from(schema.activityEpochs).all()).toEqual([])
+  })
+
+  it('rolls back every activity change and leaves no finalized marker when one batch statement fails', async () => {
+    const validatorA = await insertValidator(ADDRESS_A)
+    const validatorB = await insertValidator(ADDRESS_B)
+    const validatorC = await insertValidator(ADDRESS_C)
+    const epochNumber = 77
+
+    await harness.db.insert(schema.activity).values([
+      {
+        validatorId: validatorA.id,
+        epochNumber,
+        likelihood: 10,
+        rewarded: 1,
+        missed: 9,
+        dominanceRatioViaBalance: -1,
+        dominanceRatioViaSlots: 10,
+        balance: 100,
+        stakers: 1,
+      },
+      {
+        validatorId: validatorC.id,
+        epochNumber,
+        likelihood: 12,
+        rewarded: -1,
+        missed: -1,
+        dominanceRatioViaBalance: -1,
+        dominanceRatioViaSlots: 12,
+        balance: 300,
+        stakers: 3,
+      },
+    ]).execute()
+    await activityEpochs.beginActivityEpochAttempt(epochNumber, STARTED_AT)
+    const prepared = await prepareEpoch(epochNumber, new Map([
+      [ADDRESS_A, validatorA.id],
+      [ADDRESS_B, validatorB.id],
+    ]))
+
+    await harness.execute(`
+      CREATE TRIGGER fail_second_activity_insert
+      BEFORE INSERT ON activity
+      WHEN NEW.validator_id = ${validatorB.id}
+      BEGIN
+        SELECT RAISE(ABORT, 'forced activity batch failure');
+      END
+    `)
+
+    await expect(activityEpochs.persistCompletedEpoch(prepared, STARTED_AT, FINALIZED_AT))
+      .rejects
+      .toThrow(/forced activity batch failure/i)
+
+    expect(await harness.db.select().from(schema.activity).where(eq(schema.activity.epochNumber, epochNumber)).orderBy(asc(schema.activity.validatorId)).all())
+      .toEqual([
+        expect.objectContaining({ validatorId: validatorA.id, rewarded: 1, missed: 9 }),
+        expect.objectContaining({ validatorId: validatorC.id, likelihood: 12, rewarded: -1, missed: -1 }),
+      ])
+    expect(await harness.db.select().from(schema.activityEpochs).where(eq(schema.activityEpochs.epochNumber, epochNumber)).get())
+      .toMatchObject({
+        status: 'syncing',
+        attemptCount: 1,
+        expectedElectedCount: null,
+        storedElectedCount: null,
+        finalizedAt: null,
+      })
+
+    await activityEpochs.markActivityEpochFailed(epochNumber, new Error('forced activity batch failure'))
+    expect(await harness.db.select().from(schema.activityEpochs).where(eq(schema.activityEpochs.epochNumber, epochNumber)).get())
+      .toMatchObject({
+        status: 'failed',
+        attemptCount: 1,
+        finalizedAt: null,
+        lastError: expect.stringContaining('forced activity batch failure'),
+      })
+  })
+
+  it('removes all stale rows once inside the batch before expected activity upserts', async () => {
+    const validatorA = await insertValidator(ADDRESS_A)
+    const validatorB = await insertValidator(ADDRESS_B)
+    const validatorC = await insertValidator(ADDRESS_C)
+    const validatorD = await insertValidator(ADDRESS_D)
+    const epochNumber = 78
+
+    await harness.db.insert(schema.activity).values([
+      {
+        validatorId: validatorC.id,
+        epochNumber,
+        likelihood: 12,
+        rewarded: 700,
+        missed: 20,
+        dominanceRatioViaBalance: -1,
+        dominanceRatioViaSlots: 12,
+        balance: 300,
+        stakers: 3,
+      },
+      {
+        validatorId: validatorD.id,
+        epochNumber,
+        likelihood: -1,
+        rewarded: -1,
+        missed: -1,
+        dominanceRatioViaBalance: -1,
+        dominanceRatioViaSlots: -1,
+        balance: 400,
+        stakers: 4,
+      },
+    ]).execute()
+    await harness.execute(`
+      CREATE TRIGGER require_stale_cleanup_before_expected_upsert
+      BEFORE INSERT ON activity
+      WHEN NEW.validator_id = ${validatorA.id}
+        AND EXISTS (
+          SELECT 1 FROM activity
+          WHERE epoch_number = ${epochNumber}
+            AND validator_id IN (${validatorC.id}, ${validatorD.id})
+        )
+      BEGIN
+        SELECT RAISE(ABORT, 'stale rows were not removed first');
+      END
+    `)
+    const prepared = await prepareEpoch(epochNumber, new Map([
+      [ADDRESS_A, validatorA.id],
+      [ADDRESS_B, validatorB.id],
+    ]))
+    await activityEpochs.beginActivityEpochAttempt(epochNumber, STARTED_AT)
+    harness.trace.reset()
+
+    await activityEpochs.persistCompletedEpoch(prepared, STARTED_AT, FINALIZED_AT)
+
+    const activityReadsBeforeBatch = harness.trace.executed.filter(sql => /from\s+[`"]?activity[`"]?(?:\s|$)/i.test(sql))
+    expect(activityReadsBeforeBatch).toEqual([])
+    expect(harness.trace.batches).toHaveLength(1)
+    const batchStatements = harness.trace.batches[0]!
+    const activityDeletes = batchStatements.filter(sql => /delete\s+from\s+[`"]?activity[`"]?(?:\s|$)/i.test(sql))
+    expect(activityDeletes).toHaveLength(1)
+    expect(batchStatements).toHaveLength(Math.ceil(prepared.activities.length / 5) + 3)
+    const firstExpectedUpsertIndex = batchStatements.findIndex(sql => /insert\s+into\s+[`"]?activity[`"]?(?:\s|\()/i.test(sql))
+    const cleanupIndex = batchStatements.findIndex(sql => /delete\s+from\s+[`"]?activity[`"]?(?:\s|$)/i.test(sql))
+    expect(cleanupIndex).toBeGreaterThanOrEqual(0)
+    expect(cleanupIndex).toBeLessThan(firstExpectedUpsertIndex)
+
+    expect(await harness.db.select().from(schema.activity).where(eq(schema.activity.epochNumber, epochNumber)).orderBy(asc(schema.activity.validatorId)).all())
+      .toEqual([
+        expect.objectContaining({ validatorId: validatorA.id, likelihood: 10, rewarded: 718, missed: 2 }),
+        expect.objectContaining({ validatorId: validatorB.id, likelihood: 11, rewarded: 718, missed: 2 }),
+      ])
+  })
+
+  it('uses conflict upserts, removes stale rows, and preserves expected rows on retry', async () => {
+    const validatorA = await insertValidator(ADDRESS_A)
+    const validatorB = await insertValidator(ADDRESS_B)
+    const validatorC = await insertValidator(ADDRESS_C)
+    const epochNumber = 78
+
+    await harness.db.insert(schema.activity).values([
+      {
+        validatorId: validatorA.id,
+        epochNumber,
+        likelihood: 10,
+        rewarded: 1,
+        missed: 9,
+        dominanceRatioViaBalance: -1,
+        dominanceRatioViaSlots: 10,
+        balance: 100,
+        stakers: 1,
+      },
+      {
+        validatorId: validatorC.id,
+        epochNumber,
+        likelihood: 12,
+        rewarded: -1,
+        missed: -1,
+        dominanceRatioViaBalance: -1,
+        dominanceRatioViaSlots: 12,
+        balance: 300,
+        stakers: 3,
+      },
+    ]).execute()
+    await harness.execute(`
+      CREATE TRIGGER preserve_expected_activity_rows
+      BEFORE DELETE ON activity
+      WHEN OLD.validator_id IN (${validatorA.id}, ${validatorB.id})
+      BEGIN
+        SELECT RAISE(ABORT, 'expected activity rows must not be deleted');
+      END
+    `)
+
+    const prepared = await prepareEpoch(epochNumber, new Map([
+      [ADDRESS_A, validatorA.id],
+      [ADDRESS_B, validatorB.id],
+    ]))
+    await activityEpochs.beginActivityEpochAttempt(epochNumber, STARTED_AT)
+    await activityEpochs.persistCompletedEpoch(prepared, STARTED_AT, FINALIZED_AT)
+    await activityEpochs.persistCompletedEpoch(prepared, STARTED_AT, FINALIZED_AT)
+
+    expect(await harness.db.select().from(schema.activity).where(eq(schema.activity.epochNumber, epochNumber)).orderBy(asc(schema.activity.validatorId)).all())
+      .toEqual([
+        expect.objectContaining({
+          validatorId: validatorA.id,
+          likelihood: 10,
+          rewarded: 718,
+          missed: 2,
+          balance: 100,
+          stakers: 1,
+        }),
+        expect.objectContaining({ validatorId: validatorB.id, likelihood: 11, rewarded: 718, missed: 2 }),
+      ])
+    expect(await harness.db.select().from(schema.activityEpochs).where(eq(schema.activityEpochs.epochNumber, epochNumber)).get())
+      .toMatchObject({
+        status: 'finalized',
+        attemptCount: 1,
+        expectedElectedCount: 2,
+        storedElectedCount: 2,
+        electedSetHash: expect.stringMatching(/^[a-f\d]{64}$/),
+        finalizedAt: FINALIZED_AT,
+        lastError: null,
+      })
+  })
+
+  it('removes every prior row when a finalized epoch has no elected validators', async () => {
+    const validatorC = await insertValidator(ADDRESS_C)
+    const epochNumber = 88
+    await harness.db.insert(schema.activity).values({
+      validatorId: validatorC.id,
+      epochNumber,
+      likelihood: 12,
+      rewarded: 700,
+      missed: 20,
+      dominanceRatioViaBalance: -1,
+      dominanceRatioViaSlots: 12,
+      balance: 300,
+      stakers: 3,
+    }).execute()
+    const prepared = await activityEpochs.prepareCompletedEpoch({
+      epochNumber,
+      electionSet: { epochIndex: epochNumber, electionBlockNumber: 123_456, validators: [] },
+      activity: {},
+      validatorIds: new Map(),
+    })
+    await activityEpochs.beginActivityEpochAttempt(epochNumber, STARTED_AT)
+
+    await activityEpochs.persistCompletedEpoch(prepared, STARTED_AT, FINALIZED_AT)
+
+    expect(await harness.db.select().from(schema.activity).where(eq(schema.activity.epochNumber, epochNumber)).all()).toEqual([])
+    expect(await harness.db.select().from(schema.activityEpochs).where(eq(schema.activityEpochs.epochNumber, epochNumber)).get())
+      .toMatchObject({ status: 'finalized', expectedElectedCount: 0, storedElectedCount: 0 })
+  })
+})
+
+describe('finalized activity store path', () => {
+  it('marks a claimed epoch failed when strict validator insertion aborts finalization', async () => {
+    const epochNumber = 80
+    await harness.execute(`
+      CREATE TRIGGER fail_finalized_strict_validator_insert
+      BEFORE INSERT ON validators
+      WHEN NEW.address = '${ADDRESS_A}'
+      BEGIN
+        SELECT RAISE(ABORT, 'forced finalized strict validator failure');
+      END
+    `)
+
+    await expect(activities.storeActivities({
+      [epochNumber]: { [ADDRESS_A]: createElectedActivity(ADDRESS_A, 10) },
+    }, {
+      finalizeEpoch: true,
+      electionSets: {
+        [epochNumber]: {
+          epochIndex: epochNumber,
+          electionBlockNumber: 123_456,
+          validators: [{ address: ADDRESS_A, numSlots: 10 }],
+        },
+      },
+    })).rejects.toThrow(/validator|database|insert|query|constraint/i)
+
+    expect(await harness.db.select().from(schema.activity).where(eq(schema.activity.epochNumber, epochNumber)).all()).toEqual([])
+    expect(await harness.db.select().from(schema.activityEpochs).where(eq(schema.activityEpochs.epochNumber, epochNumber)).get())
+      .toMatchObject({
+        status: 'failed',
+        finalizedAt: null,
+        lastError: expect.stringMatching(/validator|database|insert|query|constraint/i),
+      })
+  })
+
+  it('rejects finalization when no authoritative election set is supplied', async () => {
+    await insertValidator(ADDRESS_A)
+    const epochNumber = 80
+    const activity: EpochActivity = {
+      [ADDRESS_A]: createElectedActivity(ADDRESS_A, 10),
+    }
+
+    await expect(activities.storeActivities({ [epochNumber]: activity }, { finalizeEpoch: true }))
+      .rejects
+      .toThrow(/authoritative|election|set|required/i)
+
+    expect(await harness.db.select().from(schema.activity).where(eq(schema.activity.epochNumber, epochNumber)).all()).toEqual([])
+    const marker = await harness.db.select().from(schema.activityEpochs).where(eq(schema.activityEpochs.epochNumber, epochNumber)).get()
+    expect(marker?.status).not.toBe('finalized')
+  })
+
+  it('requires an authoritative election set and rejects activity that omits an elected validator', async () => {
+    await insertValidator(ADDRESS_A)
+    await insertValidator(ADDRESS_B)
+    const epochNumber = 80
+    const partialActivity: EpochActivity = {
+      [ADDRESS_A]: createElectedActivity(ADDRESS_A, 10),
+    }
+
+    await expect(activities.storeActivities({ [epochNumber]: partialActivity }, {
+      finalizeEpoch: true,
+      electionSets: {
+        [epochNumber]: {
+          epochIndex: epochNumber,
+          electionBlockNumber: 123_456,
+          validators: [
+            { address: ADDRESS_A, numSlots: 10 },
+            { address: ADDRESS_B, numSlots: 11 },
+          ],
+        },
+      },
+    })).rejects.toThrow(/election|activity|address|set|mismatch/i)
+
+    expect(await harness.db.select().from(schema.activity).where(eq(schema.activity.epochNumber, epochNumber)).all()).toEqual([])
+    const marker = await harness.db.select().from(schema.activityEpochs).where(eq(schema.activityEpochs.epochNumber, epochNumber)).get()
+    expect(marker?.status).not.toBe('finalized')
+  })
+
+  it('reports an already-finalized epoch explicitly without changing marker or activity', async () => {
+    const validatorA = await insertValidator(ADDRESS_A)
+    const validatorB = await insertValidator(ADDRESS_B)
+    const epochNumber = 89
+    const electionSet = {
+      epochIndex: epochNumber,
+      electionBlockNumber: 123_456,
+      validators: [
+        { address: ADDRESS_A, numSlots: 10 },
+        { address: ADDRESS_B, numSlots: 11 },
+      ],
+    }
+    const activity: EpochActivity = {
+      [ADDRESS_A]: createElectedActivity(ADDRESS_A, 10),
+      [ADDRESS_B]: createElectedActivity(ADDRESS_B, 11),
+    }
+    const prepared = await activityEpochs.prepareCompletedEpoch({
+      epochNumber,
+      electionSet,
+      activity,
+      validatorIds: new Map([
+        [ADDRESS_A, validatorA.id],
+        [ADDRESS_B, validatorB.id],
+      ]),
+    })
+    await activityEpochs.beginActivityEpochAttempt(epochNumber, STARTED_AT)
+    await activityEpochs.persistCompletedEpoch(prepared, STARTED_AT, FINALIZED_AT)
+    const markerBefore = await harness.db.select().from(schema.activityEpochs).where(eq(schema.activityEpochs.epochNumber, epochNumber)).get()
+    const activityBefore = await harness.db.select().from(schema.activity).where(eq(schema.activity.epochNumber, epochNumber)).orderBy(asc(schema.activity.validatorId)).all()
+
+    const result = await activities.storeActivities({ [epochNumber]: activity }, {
+      finalizeEpoch: true,
+      electionSets: { [epochNumber]: electionSet },
+    })
+
+    expect(result).toEqual({
+      storedEpochs: [],
+      alreadyFinalizedEpochs: [epochNumber],
+      provisioningEpochs: [],
+    })
+    expect(await harness.db.select().from(schema.activityEpochs).where(eq(schema.activityEpochs.epochNumber, epochNumber)).get()).toEqual(markerBefore)
+    expect(await harness.db.select().from(schema.activity).where(eq(schema.activity.epochNumber, epochNumber)).orderBy(asc(schema.activity.validatorId)).all()).toEqual(activityBefore)
+  })
+
+  it('finalizes multiple epochs sharing one uncached validator without racing its unique address insert', async () => {
+    const epochNumbers = [81, 82, 83, 84, 85]
+    armLogoBarrier(ADDRESS_SHARED, epochNumbers.length)
+    const epochActivities = Object.fromEntries(epochNumbers.map(epochNumber => [epochNumber, {
+      [ADDRESS_SHARED]: createElectedActivity(ADDRESS_SHARED, 10),
+    }]))
+    const electionSets = Object.fromEntries(epochNumbers.map(epochNumber => [epochNumber, {
+      epochIndex: epochNumber,
+      electionBlockNumber: 123_456 + epochNumber,
+      validators: [{ address: ADDRESS_SHARED, numSlots: 10 }],
+    }]))
+
+    const storePromise = activities.storeActivities(epochActivities, {
+      finalizeEpoch: true,
+      electionSets,
+    })
+    await logoBarrierState.firstArrival
+    await Promise.race([
+      logoBarrierState.allArrived!,
+      new Promise(resolve => setTimeout(resolve, 100)),
+    ])
+    logoBarrierState.release?.()
+
+    await expect(storePromise).resolves.toEqual({
+      storedEpochs: epochNumbers,
+      alreadyFinalizedEpochs: [],
+      provisioningEpochs: [],
+    })
+
+    expect(await harness.db.select({ address: schema.validators.address }).from(schema.validators).all())
+      .toEqual([{ address: ADDRESS_SHARED }])
+    expect(await harness.db.select().from(schema.activity).orderBy(asc(schema.activity.epochNumber)).all())
+      .toHaveLength(epochNumbers.length)
+    expect(await harness.db.select().from(schema.activityEpochs).orderBy(asc(schema.activityEpochs.epochNumber)).all())
+      .toEqual(epochNumbers.map(epochNumber => expect.objectContaining({
+        epochNumber,
+        status: 'finalized',
+        expectedElectedCount: 1,
+        storedElectedCount: 1,
+      })))
+  })
+})
+
+describe('worst-case finalized epoch query budget', () => {
+  it('bulk-resolves 512 uncached existing validators and stays below the D1 invocation ceiling', async () => {
+    const epochNumber = 87
+    const addresses = Array.from({ length: 512 }, (_, index) => `bulk-validator-${index.toString().padStart(3, '0')}`)
+    const insertedValidators = await harness.db.insert(schema.validators).values(addresses.map(address => ({
+      address,
+      name: 'Bulk validator',
+      logo: 'test-logo',
+      hasDefaultLogo: true,
+      accentColor: '#000000',
+    }))).returning({
+      id: schema.validators.id,
+      address: schema.validators.address,
+    }).all()
+    const activity = Object.fromEntries(addresses.map(address => [
+      address,
+      createElectedActivity(address, 1),
+    ]))
+    const electionSet = {
+      epochIndex: epochNumber,
+      electionBlockNumber: 123_456,
+      validators: addresses.map(address => ({ address, numSlots: 1 })),
+    }
+    harness.trace.reset()
+
+    const result = await activities.storeActivities({ [epochNumber]: activity }, {
+      finalizeEpoch: true,
+      electionSets: { [epochNumber]: electionSet },
+    })
+
+    expect(result).toEqual({
+      storedEpochs: [epochNumber],
+      alreadyFinalizedEpochs: [],
+      provisioningEpochs: [],
+    })
+    expect(harness.trace.batches).toHaveLength(1)
+    const batchStatements = harness.trace.batches[0]!
+    const maxActivityUpsertStatements = Math.ceil(addresses.length / 5)
+    const activityUpsertStatements = batchStatements.filter(sql => /insert\s+into\s+[`"]?activity[`"]?(?:\s|\()/i.test(sql))
+    expect(activityUpsertStatements.length).toBeLessThanOrEqual(maxActivityUpsertStatements)
+    expect(batchStatements.length).toBeLessThanOrEqual(maxActivityUpsertStatements + 3)
+    const firstActivityUpsertIndex = batchStatements.findIndex(sql => /insert\s+into\s+[`"]?activity[`"]?(?:\s|\()/i.test(sql))
+    const cleanupIndex = batchStatements.findIndex(sql => /delete\s+from\s+[`"]?activity[`"]?(?:\s|$)/i.test(sql))
+    expect(cleanupIndex).toBeGreaterThanOrEqual(0)
+    expect(cleanupIndex).toBeLessThan(firstActivityUpsertIndex)
+    expect(batchStatements.at(-1)).toMatch(/update\s+[`"]?activity_epochs[`"]?\s+set/i)
+    const validatorReads = harness.trace.executed.filter(sql => /from\s+[`"]?validators[`"]?(?:\s|$)/i.test(sql))
+    expect(validatorReads.length).toBeLessThanOrEqual(8)
+    const tracedD1Statements = harness.trace.executed.length
+      + harness.trace.batches.reduce((count, statements) => count + statements.length, 0)
+    expect(tracedD1Statements).toBeLessThan(1_000)
+    expect(await harness.db.select().from(schema.activity).where(eq(schema.activity.epochNumber, epochNumber)).all())
+      .toHaveLength(insertedValidators.length)
+    expect(await harness.db.select().from(schema.activityEpochs).where(eq(schema.activityEpochs.epochNumber, epochNumber)).get())
+      .toMatchObject({
+        status: 'finalized',
+        expectedElectedCount: 512,
+        storedElectedCount: 512,
+      })
+  }, 30_000)
+
+  it('keeps combined completed and snapshot persistence bounded, metadata-safe, and idempotent', async () => {
+    const completedEpoch = 90
+    const snapshotEpoch = 91
+    const addresses = Array.from({ length: 512 }, (_, index) => `combined-validator-${index.toString().padStart(3, '0')}`)
+    const insertedValidators = await harness.db.insert(schema.validators).values(addresses.map(address => ({
+      address,
+      name: 'Combined validator',
+      logo: 'test-logo',
+      hasDefaultLogo: true,
+      accentColor: '#000000',
+    }))).returning({
+      id: schema.validators.id,
+      address: schema.validators.address,
+    }).all()
+    const validatorIdByAddress = new Map(insertedValidators.map(validator => [validator.address, validator.id]))
+    const completedActivity = Object.fromEntries(addresses.map((address, index) => {
+      const activity = createElectedActivity(address, 1)
+      if (index === 0)
+        return [address, { ...activity, balance: 1_000, stakers: 10 }]
+      if (index === 1)
+        return [address, { ...activity, balance: 2_000, stakers: 0 }]
+      return [address, activity]
+    }))
+    const snapshotActivity = Object.fromEntries(addresses.map((address, index) => {
+      const activity = {
+        ...createElectedActivity(address, 1),
+        missed: -1,
+        rewarded: -1,
+      }
+      if (index === 1)
+        return [address, { ...activity, balance: 3_000, stakers: 0 }]
+      return [address, activity]
+    }))
+    const electionSet = {
+      epochIndex: completedEpoch,
+      electionBlockNumber: 123_456,
+      validators: addresses.map(address => ({ address, numSlots: 1 })),
+    }
+
+    harness.trace.reset()
+    const completedResult = await activities.storeActivities({ [completedEpoch]: completedActivity }, {
+      finalizeEpoch: true,
+      electionSets: { [completedEpoch]: electionSet },
+    })
+    const completedStatementCount = harness.trace.executed.length
+      + harness.trace.batches.reduce((count, statements) => count + statements.length, 0)
+    expect(completedResult).toEqual({
+      storedEpochs: [completedEpoch],
+      alreadyFinalizedEpochs: [],
+      provisioningEpochs: [],
+    })
+
+    harness.trace.reset()
+    await activities.storeActivities({ [snapshotEpoch]: snapshotActivity })
+    const snapshotStatements = [
+      ...harness.trace.executed,
+      ...harness.trace.batches.flat(),
+    ]
+    const snapshotStatementCount = snapshotStatements.length
+    const snapshotValidatorReads = snapshotStatements.filter(sql => /from\s+[`"]?validators[`"]?(?:\s|$)/i.test(sql))
+    const snapshotActivityReads = snapshotStatements.filter(sql => /from\s+[`"]?activity[`"]?(?:\s|$)/i.test(sql))
+    const snapshotActivityUpserts = snapshotStatements.filter(sql => /insert\s+into\s+[`"]?activity[`"]?(?:\s|\()/i.test(sql))
+    expect(snapshotValidatorReads.length).toBeLessThanOrEqual(1)
+    expect(snapshotActivityReads.length).toBeLessThanOrEqual(2)
+    expect(snapshotActivityUpserts.length).toBeLessThanOrEqual(Math.ceil(addresses.length / 5))
+    expect(completedStatementCount + snapshotStatementCount).toBeLessThan(500)
+
+    harness.trace.reset()
+    await activities.storeActivities({ [snapshotEpoch]: snapshotActivity })
+    const retryStatementCount = harness.trace.executed.length
+      + harness.trace.batches.reduce((count, statements) => count + statements.length, 0)
+    expect(retryStatementCount).toBeLessThan(200)
+
+    const snapshotRows = await harness.db.select().from(schema.activity).where(eq(schema.activity.epochNumber, snapshotEpoch)).all()
+    expect(snapshotRows).toHaveLength(addresses.length)
+    expect(snapshotRows.find(row => row.validatorId === validatorIdByAddress.get(addresses[0]!)))
+      .toMatchObject({ balance: 1_000, stakers: 10, missed: -1, rewarded: -1 })
+    expect(snapshotRows.find(row => row.validatorId === validatorIdByAddress.get(addresses[1]!)))
+      .toMatchObject({ balance: 3_000, stakers: 0, missed: -1, rewarded: -1 })
+  }, 60_000)
+
+  it('provisions 512 absent snapshot validators in chunks before writing any activity', async () => {
+    const snapshotEpoch = 92
+    const validatorCount = 512
+    const provisioningChunkSize = 200
+    const addresses = Array.from({ length: validatorCount }, (_, index) => `missing-snapshot-validator-${index.toString().padStart(3, '0')}`)
+    const snapshotActivity = Object.fromEntries(addresses.map(address => [
+      address,
+      {
+        ...createElectedActivity(address, 1),
+        missed: -1,
+        rewarded: -1,
+      },
+    ]))
+    const expectedValidatorCounts = [
+      provisioningChunkSize,
+      provisioningChunkSize * 2,
+      validatorCount,
+    ]
+
+    for (const [attemptIndex, expectedValidatorCount] of expectedValidatorCounts.entries()) {
+      harness.trace.reset()
+      const result = await activities.storeActivities({ [snapshotEpoch]: snapshotActivity })
+      const tracedStatements = [
+        ...harness.trace.executed,
+        ...harness.trace.batches.flat(),
+      ]
+
+      expect(tracedStatements.length).toBeLessThan(1_000)
+      expect(await harness.db.select().from(schema.validators).all()).toHaveLength(expectedValidatorCount)
+
+      if (attemptIndex < expectedValidatorCounts.length - 1) {
+        expect(result).toEqual({
+          storedEpochs: [],
+          alreadyFinalizedEpochs: [],
+          provisioningEpochs: [snapshotEpoch],
+        })
+        expect(tracedStatements.filter(sql => /(?:insert\s+into|update|delete\s+from)\s+[`"]?activity[`"]?(?:\s|\()/i.test(sql))).toEqual([])
+        expect(await harness.db.select().from(schema.activity).where(eq(schema.activity.epochNumber, snapshotEpoch)).all()).toEqual([])
+      }
+      else {
+        expect(result).toEqual({
+          storedEpochs: [snapshotEpoch],
+          alreadyFinalizedEpochs: [],
+          provisioningEpochs: [],
+        })
+        expect(await harness.db.select().from(schema.activity).where(eq(schema.activity.epochNumber, snapshotEpoch)).all())
+          .toHaveLength(validatorCount)
+      }
+    }
+  }, 60_000)
+
+  it('lets the bounded snapshot store own absent-validator provisioning', async () => {
+    const snapshotEpoch = 93
+    const addresses = Array.from({ length: 512 }, (_, index) => `active-snapshot-validator-${index.toString().padStart(3, '0')}`)
+    const validators = addresses.map(address => ({
+      ...createElectedActivity(address, 1),
+      missed: -1,
+      rewarded: -1,
+      balance: 1_000,
+    }))
+    fetcherMocks.fetchSnapshotEpoch.mockResolvedValue([true, undefined, {
+      epochNumber: snapshotEpoch,
+      validators,
+    }])
+    harness.trace.reset()
+
+    const result = await activities.fetchActiveEpoch()
+    const tracedStatements = [
+      ...harness.trace.executed,
+      ...harness.trace.batches.flat(),
+    ]
+
+    expect(result).toEqual([true, undefined, expect.objectContaining({
+      epochNumber: snapshotEpoch,
+      storageOutcome: 'provisioning',
+    })])
+    expect(tracedStatements.length).toBeLessThan(1_000)
+    expect(tracedStatements.filter(sql => /(?:insert\s+into|update|delete\s+from)\s+[`"]?activity[`"]?(?:\s|\()/i.test(sql))).toEqual([])
+    expect(await harness.db.select().from(schema.validators).all()).toHaveLength(200)
+    expect(await harness.db.select().from(schema.activity).where(eq(schema.activity.epochNumber, snapshotEpoch)).all()).toEqual([])
+  }, 60_000)
+
+  it('provisions genuinely absent validators in safe chunks and finalizes only after all IDs exist', async () => {
+    const epochNumber = 88
+    const validatorCount = 512
+    const provisioningChunkSize = 200
+    const addresses = Array.from({ length: validatorCount }, (_, index) => `missing-validator-${index.toString().padStart(3, '0')}`)
+    const activity = Object.fromEntries(addresses.map(address => [
+      address,
+      createElectedActivity(address, 1),
+    ]))
+    const electionSet = {
+      epochIndex: epochNumber,
+      electionBlockNumber: 123_456,
+      validators: addresses.map(address => ({ address, numSlots: 1 })),
+    }
+    const expectedValidatorCounts = [
+      provisioningChunkSize,
+      provisioningChunkSize * 2,
+      validatorCount,
+    ]
+
+    for (const [attemptIndex, expectedValidatorCount] of expectedValidatorCounts.entries()) {
+      harness.trace.reset()
+      const result = await activities.storeActivities({ [epochNumber]: activity }, {
+        finalizeEpoch: true,
+        electionSets: { [epochNumber]: electionSet },
+      })
+      const tracedD1Statements = harness.trace.executed.length
+        + harness.trace.batches.reduce((count, statements) => count + statements.length, 0)
+
+      expect(tracedD1Statements).toBeLessThan(1_000)
+      expect(await harness.db.select().from(schema.validators).all()).toHaveLength(expectedValidatorCount)
+      if (attemptIndex < expectedValidatorCounts.length - 1) {
+        expect(result).toEqual({
+          storedEpochs: [],
+          alreadyFinalizedEpochs: [],
+          provisioningEpochs: [epochNumber],
+        })
+        const activityBatchStatements = harness.trace.batches.flat().filter(sql => /(?:insert\s+into|update)\s+[`"]?activity[`"]?(?:\s|\()/i.test(sql))
+        expect(activityBatchStatements).toEqual([])
+        expect(await harness.db.select().from(schema.activity).where(eq(schema.activity.epochNumber, epochNumber)).all()).toEqual([])
+        const marker = await harness.db.select().from(schema.activityEpochs).where(eq(schema.activityEpochs.epochNumber, epochNumber)).get()
+        expect(marker?.status).not.toBe('finalized')
+        expect(marker?.finalizedAt).toBeNull()
+      }
+      else {
+        expect(result).toEqual({
+          storedEpochs: [epochNumber],
+          alreadyFinalizedEpochs: [],
+          provisioningEpochs: [],
+        })
+        expect(harness.trace.batches).toHaveLength(1)
+        expect(await harness.db.select().from(schema.activity).where(eq(schema.activity.epochNumber, epochNumber)).all())
+          .toHaveLength(validatorCount)
+        expect(await harness.db.select().from(schema.activityEpochs).where(eq(schema.activityEpochs.epochNumber, epochNumber)).get())
+          .toMatchObject({
+            status: 'finalized',
+            expectedElectedCount: validatorCount,
+            storedElectedCount: validatorCount,
+          })
+      }
+    }
+  }, 60_000)
+})
+
+describe('marker-based completeness', () => {
+  it('derives missing epochs only from finalized markers, not activity-row heuristics', async () => {
+    const validator = await insertValidator(ADDRESS_A)
+
+    await harness.db.insert(schema.activity).values({
+      validatorId: validator.id,
+      epochNumber: 70,
+      likelihood: 10,
+      rewarded: 720,
+      missed: 0,
+      dominanceRatioViaBalance: -1,
+      dominanceRatioViaSlots: 10,
+      balance: -1,
+      stakers: 0,
+    }).execute()
+    await harness.db.insert(schema.activityEpochs).values([
+      {
+        epochNumber: 71,
+        status: 'finalized',
+        expectedElectedCount: 0,
+        storedElectedCount: 0,
+        electedSetHash: 'empty-election-set',
+        attemptCount: 1,
+        startedAt: STARTED_AT,
+        finalizedAt: FINALIZED_AT,
+        lastError: null,
+      },
+      {
+        epochNumber: 72,
+        status: 'failed',
+        attemptCount: 1,
+        startedAt: STARTED_AT,
+        lastError: 'RPC unavailable',
+      },
+    ]).execute()
+
+    expect(await activities.findMissingEpochs(createRange(70, 72))).toEqual([70, 72])
+
+    const finalizedMarkers = await harness.db.select({ epochNumber: schema.activityEpochs.epochNumber })
+      .from(schema.activityEpochs)
+      .where(and(
+        eq(schema.activityEpochs.status, 'finalized'),
+        eq(schema.activityEpochs.epochNumber, 71),
+      ))
+      .all()
+    expect(finalizedMarkers).toEqual([{ epochNumber: 71 }])
+  })
+})
diff --git a/server/utils/activity-sync.test.ts b/server/utils/activity-sync.test.ts
new file mode 100644
index 00000000..9aaf16e4
--- /dev/null
+++ b/server/utils/activity-sync.test.ts
@@ -0,0 +1,194 @@
+import type { ElectionSet, EpochActivity } from 'nimiq-validator-trustscore/types'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { synchronizeCompletedEpoch } from './activity-sync'
+
+vi.mock('./drizzle', () => ({
+  tables: {
+    activity: {
+      epochNumber: 'epoch_number',
+      likelihood: 'likelihood',
+      missed: 'missed',
+      rewarded: 'rewarded',
+      validatorId: 'validator_id',
+    },
+    validators: {
+      id: 'id',
+      address: 'address',
+    },
+  },
+  useDrizzle: vi.fn(),
+}))
+
+vi.mock('./activities', () => ({
+  repairCompletedEpoch: vi.fn(),
+  resolveCompletedEpochValidatorIds: vi.fn(),
+}))
+
+vi.mock('./activity-epochs', () => ({
+  beginActivityEpochAttempt: vi.fn(),
+  finalizeVerifiedCompletedEpoch: vi.fn(),
+  markActivityEpochFailed: vi.fn(),
+}))
+
+vi.mock('~~/packages/nimiq-validator-trustscore/src/fetcher', () => ({
+  fetchActivity: vi.fn(),
+  fetchElectionSet: vi.fn(),
+}))
+
+const EPOCH = 42
+const ADDRESS_A = 'NQ02 31N6 3KM5 T6G5 22TN EPF5 5XPY RLHK RMB3'
+const ADDRESS_B = 'NQ29 FBVT B4GM S27H UBP4 1MTC GNKQ VPBT 099M'
+
+const electionSet: ElectionSet = {
+  epochIndex: EPOCH,
+  electionBlockNumber: 123_456,
+  validators: [
+    { address: ADDRESS_A, numSlots: 256 },
+    { address: ADDRESS_B, numSlots: 256 },
+  ],
+}
+
+const activity: EpochActivity = {
+  [ADDRESS_A]: {
+    address: ADDRESS_A,
+    elected: true,
+    likelihood: 256,
+    missed: 0,
+    rewarded: 720,
+    dominanceRatioViaBalance: -1,
+    dominanceRatioViaSlots: 0.5,
+    balance: -1,
+    stakers: 0,
+  },
+  [ADDRESS_B]: {
+    address: ADDRESS_B,
+    elected: true,
+    likelihood: 256,
+    missed: 0,
+    rewarded: 720,
+    dominanceRatioViaBalance: -1,
+    dominanceRatioViaSlots: 0.5,
+    balance: -1,
+    stakers: 0,
+  },
+}
+
+function createDependencies() {
+  return {
+    beginActivityEpochAttempt: vi.fn().mockResolvedValue(true),
+    fetchElectionSet: vi.fn().mockResolvedValue([true, undefined, electionSet]),
+    fetchActivity: vi.fn().mockResolvedValue([true, undefined, activity]),
+    getStoredFinalizedElectedAddresses: vi.fn().mockResolvedValue([ADDRESS_B.replaceAll(' ', ''), ADDRESS_A]),
+    finalizeVerifiedEpoch: vi.fn().mockResolvedValue(undefined),
+    repairCompletedEpoch: vi.fn().mockResolvedValue(undefined),
+    markActivityEpochFailed: vi.fn().mockResolvedValue(undefined),
+    now: vi.fn().mockReturnValue(new Date('2026-07-29T12:00:00.000Z')),
+    allowRepair: true,
+  }
+}
+
+describe('synchronizeCompletedEpoch', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  it('verifies an exact stored elected-address set without a full activity fetch', async () => {
+    const dependencies = createDependencies()
+
+    await expect(synchronizeCompletedEpoch(EPOCH, 'testnet', dependencies)).resolves.toEqual({
+      epochNumber: EPOCH,
+      status: 'verified',
+    })
+
+    expect(dependencies.fetchElectionSet).toHaveBeenCalledWith(EPOCH, { network: 'testnet' })
+    expect(dependencies.getStoredFinalizedElectedAddresses).toHaveBeenCalledWith(EPOCH)
+    expect(dependencies.fetchActivity).not.toHaveBeenCalled()
+    expect(dependencies.finalizeVerifiedEpoch).toHaveBeenCalledWith(
+      EPOCH,
+      electionSet,
+      '2026-07-29T12:00:00.000Z',
+    )
+    expect(dependencies.repairCompletedEpoch).not.toHaveBeenCalled()
+  })
+
+  it('refetches and atomically repairs a mismatched stored elected-address set', async () => {
+    const dependencies = createDependencies()
+    dependencies.getStoredFinalizedElectedAddresses.mockResolvedValue([ADDRESS_A])
+
+    await expect(synchronizeCompletedEpoch(EPOCH, 'testnet', dependencies)).resolves.toEqual({
+      epochNumber: EPOCH,
+      status: 'repaired',
+    })
+
+    expect(dependencies.fetchActivity).toHaveBeenCalledWith(EPOCH, expect.objectContaining({
+      network: 'testnet',
+      electionSet,
+    }))
+    expect(dependencies.repairCompletedEpoch).toHaveBeenCalledWith(
+      EPOCH,
+      electionSet,
+      activity,
+      '2026-07-29T12:00:00.000Z',
+    )
+    expect(dependencies.finalizeVerifiedEpoch).not.toHaveBeenCalled()
+  })
+
+  it('returns a failed outcome and records marker failure when full activity fetch fails', async () => {
+    const dependencies = createDependencies()
+    dependencies.getStoredFinalizedElectedAddresses.mockResolvedValue([])
+    dependencies.fetchActivity.mockResolvedValue([false, 'RPC unavailable', undefined])
+
+    await expect(synchronizeCompletedEpoch(EPOCH, 'testnet', dependencies)).resolves.toEqual({
+      epochNumber: EPOCH,
+      status: 'failed',
+      error: 'RPC unavailable',
+      repairAttempted: true,
+    })
+
+    expect(dependencies.markActivityEpochFailed).toHaveBeenCalledWith(
+      EPOCH,
+      expect.objectContaining({ message: 'RPC unavailable' }),
+      '2026-07-29T12:00:00.000Z',
+    )
+    expect(dependencies.repairCompletedEpoch).not.toHaveBeenCalled()
+  })
+
+  it('defers a mismatched epoch without fetching activity when repair is disallowed', async () => {
+    const dependencies = createDependencies()
+    dependencies.getStoredFinalizedElectedAddresses.mockResolvedValue([ADDRESS_A])
+    dependencies.allowRepair = false
+
+    const outcome = await synchronizeCompletedEpoch(EPOCH, 'testnet', dependencies)
+
+    expect(outcome).toEqual({
+      epochNumber: EPOCH,
+      status: 'failed',
+      error: expect.stringMatching(/repair|defer|budget/i),
+      repairAttempted: false,
+    })
+    expect(dependencies.fetchActivity).not.toHaveBeenCalled()
+    expect(dependencies.repairCompletedEpoch).not.toHaveBeenCalled()
+    expect(dependencies.markActivityEpochFailed).toHaveBeenCalledWith(
+      EPOCH,
+      expect.objectContaining({ message: expect.stringMatching(/repair|defer|budget/i) }),
+      '2026-07-29T12:00:00.000Z',
+    )
+  })
+
+  it('returns already_finalized without fetching when attempt claim is refused', async () => {
+    const dependencies = createDependencies()
+    dependencies.beginActivityEpochAttempt.mockResolvedValue(false)
+
+    await expect(synchronizeCompletedEpoch(EPOCH, 'testnet', dependencies)).resolves.toEqual({
+      epochNumber: EPOCH,
+      status: 'already_finalized',
+    })
+
+    expect(dependencies.fetchElectionSet).not.toHaveBeenCalled()
+    expect(dependencies.getStoredFinalizedElectedAddresses).not.toHaveBeenCalled()
+    expect(dependencies.fetchActivity).not.toHaveBeenCalled()
+    expect(dependencies.finalizeVerifiedEpoch).not.toHaveBeenCalled()
+    expect(dependencies.repairCompletedEpoch).not.toHaveBeenCalled()
+    expect(dependencies.markActivityEpochFailed).not.toHaveBeenCalled()
+  })
+})
diff --git a/server/utils/activity-sync.ts b/server/utils/activity-sync.ts
new file mode 100644
index 00000000..d1514ddd
--- /dev/null
+++ b/server/utils/activity-sync.ts
@@ -0,0 +1,144 @@
+import type { ElectionSet, EpochActivity } from 'nimiq-validator-trustscore/types'
+import { and, eq, gte, not } from 'drizzle-orm'
+import { fetchActivity, fetchElectionSet } from '~~/packages/nimiq-validator-trustscore/src/fetcher'
+import {
+  repairCompletedEpoch as repairCompletedEpochDefault,
+  resolveCompletedEpochValidatorIds,
+} from './activities'
+import {
+  beginActivityEpochAttempt,
+  finalizeVerifiedCompletedEpoch,
+  markActivityEpochFailed,
+} from './activity-epochs'
+import { compareCanonicalAddressSets } from './activity-integrity'
+import { tables, useDrizzle } from './drizzle'
+
+export type EpochSyncOutcome
+  = | { epochNumber: number, status: 'already_finalized' }
+    | { epochNumber: number, status: 'verified' }
+    | { epochNumber: number, status: 'repaired' }
+    | { epochNumber: number, status: 'failed', error: string, repairAttempted: boolean }
+
+type ElectionSetResult = [success: boolean, error?: string, electionSet?: ElectionSet]
+type ActivityResult = [success: boolean, error?: string, activity?: EpochActivity]
+
+export interface ActivitySyncDependencies {
+  beginActivityEpochAttempt: (epochNumber: number, startedAt: string) => Promise<boolean>
+  fetchElectionSet: (epochNumber: number, options: { network: string }) => Promise<ElectionSetResult>
+  fetchActivity: (epochNumber: number, options: { network: string, electionSet: ElectionSet, maxBatchSize?: number }) => Promise<ActivityResult>
+  getStoredFinalizedElectedAddresses: (epochNumber: number) => Promise<string[]>
+  finalizeVerifiedEpoch: (epochNumber: number, electionSet: ElectionSet, startedAt: string) => Promise<void>
+  repairCompletedEpoch: (epochNumber: number, electionSet: ElectionSet, activity: EpochActivity, startedAt: string) => Promise<void>
+  markActivityEpochFailed: (epochNumber: number, error: Error, startedAt: string) => Promise<void>
+  now: () => Date
+  allowRepair: boolean
+}
+
+async function getStoredFinalizedElectedAddresses(epochNumber: number): Promise<string[]> {
+  const rows = await useDrizzle()
+    .select({ address: tables.validators.address })
+    .from(tables.activity)
+    .innerJoin(tables.validators, eq(tables.activity.validatorId, tables.validators.id))
+    .where(and(
+      eq(tables.activity.epochNumber, epochNumber),
+      not(eq(tables.activity.likelihood, -1)),
+      gte(tables.activity.missed, 0),
+      gte(tables.activity.rewarded, 0),
+    ))
+    .all()
+  return rows.map(row => row.address)
+}
+
+async function finalizeVerifiedEpoch(epochNumber: number, electionSet: ElectionSet, startedAt: string): Promise<void> {
+  const resolution = await resolveCompletedEpochValidatorIds(
+    electionSet.validators.map(({ address }) => address),
+  )
+  if (!resolution.complete)
+    throw new Error(`Validator provisioning is incomplete for verified epoch ${epochNumber}`)
+
+  await finalizeVerifiedCompletedEpoch(
+    epochNumber,
+    electionSet,
+    resolution.validatorIds,
+    startedAt,
+    new Date().toISOString(),
+  )
+}
+
+function formatError(error: unknown): string {
+  if (error instanceof Error)
+    return error.message || error.name
+  if (typeof error === 'string')
+    return error
+  try {
+    return JSON.stringify(error) || String(error)
+  }
+  catch {
+    return String(error)
+  }
+}
+
+const defaultDependencies: ActivitySyncDependencies = {
+  beginActivityEpochAttempt,
+  fetchElectionSet,
+  fetchActivity,
+  getStoredFinalizedElectedAddresses,
+  finalizeVerifiedEpoch,
+  repairCompletedEpoch: repairCompletedEpochDefault,
+  markActivityEpochFailed,
+  now: () => new Date(),
+  allowRepair: true,
+}
+
+export async function synchronizeCompletedEpoch(
+  epochNumber: number,
+  network: string,
+  deps: Partial<ActivitySyncDependencies> = {},
+): Promise<EpochSyncOutcome> {
+  const dependencies = { ...defaultDependencies, ...deps }
+  const startedAt = dependencies.now().toISOString()
+  let repairAttempted = false
+
+  try {
+    if (!await dependencies.beginActivityEpochAttempt(epochNumber, startedAt))
+      return { epochNumber, status: 'already_finalized' }
+
+    const [electionSetOk, electionSetError, electionSet] = await dependencies.fetchElectionSet(epochNumber, { network })
+    if (!electionSetOk || !electionSet)
+      throw new Error(electionSetError || 'Unable to fetch election set')
+
+    const storedAddresses = await dependencies.getStoredFinalizedElectedAddresses(epochNumber)
+    if (compareCanonicalAddressSets(
+      electionSet.validators.map(validator => validator.address),
+      storedAddresses,
+    ).matches) {
+      await dependencies.finalizeVerifiedEpoch(epochNumber, electionSet, startedAt)
+      return { epochNumber, status: 'verified' }
+    }
+
+    if (!dependencies.allowRepair)
+      throw new Error(`Repair budget exhausted; epoch ${epochNumber} deferred`)
+
+    repairAttempted = true
+    const [activityOk, activityError, activity] = await dependencies.fetchActivity(epochNumber, {
+      network,
+      electionSet,
+      maxBatchSize: import.meta.dev ? 120 : 6,
+    })
+    if (!activityOk || !activity)
+      throw new Error(activityError || 'Unable to fetch activity')
+
+    await dependencies.repairCompletedEpoch(epochNumber, electionSet, activity, startedAt)
+    return { epochNumber, status: 'repaired' }
+  }
+  catch (error) {
+    const message = formatError(error)
+    try {
+      await dependencies.markActivityEpochFailed(epochNumber, new Error(message), startedAt)
+    }
+    catch {
+      // Failure reporting must not make a planned later epoch unreachable.
+    }
+    return { epochNumber, status: 'failed', error: message, repairAttempted }
+  }
+}
diff --git a/server/utils/cron-task-runner.test.ts b/server/utils/cron-task-runner.test.ts
new file mode 100644
index 00000000..0127b7e4
--- /dev/null
+++ b/server/utils/cron-task-runner.test.ts
@@ -0,0 +1,26 @@
+import { describe, expect, it, vi } from 'vitest'
+import { runTasksBestEffort } from './cron-task-runner'
+
+describe('runTasksBestEffort', () => {
+  it('runs every task once in order and normalizes returned and thrown failures', async () => {
+    const run = vi.fn()
+      .mockResolvedValueOnce({ result: { success: false, error: 'epochs RPC unavailable' } })
+      .mockRejectedValueOnce(new Error('snapshot import failed'))
+      .mockResolvedValueOnce({ result: { success: true } })
+
+    await expect(runTasksBestEffort([
+      'sync:epochs',
+      'sync:snapshot',
+      'sync:scores',
+    ], run)).resolves.toEqual([
+      { name: 'sync:epochs', success: false, error: 'epochs RPC unavailable' },
+      { name: 'sync:snapshot', success: false, error: 'snapshot import failed' },
+      { name: 'sync:scores', success: true, value: { result: { success: true } } },
+    ])
+
+    expect(run).toHaveBeenCalledTimes(3)
+    expect(run).toHaveBeenNthCalledWith(1, 'sync:epochs')
+    expect(run).toHaveBeenNthCalledWith(2, 'sync:snapshot')
+    expect(run).toHaveBeenNthCalledWith(3, 'sync:scores')
+  })
+})
diff --git a/server/utils/cron-task-runner.ts b/server/utils/cron-task-runner.ts
new file mode 100644
index 00000000..fa20445f
--- /dev/null
+++ b/server/utils/cron-task-runner.ts
@@ -0,0 +1,57 @@
+export interface TaskExecutionResult {
+  name: string
+  success: boolean
+  value?: unknown
+  error?: string
+}
+
+function formatError(error: unknown): string {
+  if (error instanceof Error)
+    return error.message || error.name
+  if (typeof error === 'string')
+    return error
+  if (error === undefined)
+    return 'Task returned success: false'
+  try {
+    return JSON.stringify(error) || String(error)
+  }
+  catch {
+    return String(error)
+  }
+}
+
+function isFailedTaskResult(value: unknown): value is { result: { success: false, error?: unknown } } {
+  return typeof value === 'object'
+    && value !== null
+    && 'result' in value
+    && typeof value.result === 'object'
+    && value.result !== null
+    && 'success' in value.result
+    && value.result.success === false
+}
+
+export async function runTasksBestEffort(
+  taskNames: readonly string[],
+  run: (name: string) => Promise<unknown>,
+): Promise<TaskExecutionResult[]> {
+  const results: TaskExecutionResult[] = []
+  for (const name of taskNames) {
+    try {
+      const value = await run(name)
+      if (isFailedTaskResult(value)) {
+        results.push({
+          name,
+          success: false,
+          error: formatError(value.result.error),
+        })
+      }
+      else {
+        results.push({ name, success: true, value })
+      }
+    }
+    catch (error) {
+      results.push({ name, success: false, error: formatError(error) })
+    }
+  }
+  return results
+}
diff --git a/server/utils/drizzle.ts b/server/utils/drizzle.ts
index 6913500c..25d5c6d6 100644
--- a/server/utils/drizzle.ts
+++ b/server/utils/drizzle.ts
@@ -1,6 +1,6 @@
 import { db, schema } from 'hub:db'
 
-export { and, eq, or, sql } from 'drizzle-orm'
+export type { ScoreDataStatus, ScoreVersion } from '../db/schema'
 
 export const tables = schema
 
@@ -12,7 +12,10 @@ export type Validator = typeof schema.validators.$inferSelect
 export type NewValidator = typeof schema.validators.$inferInsert
 export type Activity = typeof schema.activity.$inferSelect
 export type NewActivity = typeof schema.activity.$inferInsert
+export type ActivityEpoch = typeof schema.activityEpochs.$inferSelect
+export type NewActivityEpoch = typeof schema.activityEpochs.$inferInsert
 export type Score = typeof schema.scores.$inferSelect
 export type NewScore = typeof schema.scores.$inferInsert
+export { and, eq, or, sql } from 'drizzle-orm'
 export type CronRun = typeof schema.cronRuns.$inferSelect
 export type NewCronRun = typeof schema.cronRuns.$inferInsert
diff --git a/server/utils/schemas.ts b/server/utils/schemas.ts
index 83a5d86e..38adb298 100644
--- a/server/utils/schemas.ts
+++ b/server/utils/schemas.ts
@@ -61,6 +61,8 @@ export const mainQuerySchema = z.object({
   'with-identicons': z.literal('true').or(z.literal('false')).optional().transform(v => v === undefined ? undefined : v === 'true'),
   'force': z.literal('true').or(z.literal('false')).default('false').transform(v => v === 'true'),
   'epoch-number': z.coerce.number().min(1).default(1),
+  'score-version': z.coerce.number().pipe(z.literal(1).or(z.literal(2))).optional(),
 })
 
 export type MainQuerySchema = z.infer<typeof mainQuerySchema>
+export const scoreVersionQuerySchema = mainQuerySchema.pick({ 'score-version': true })
diff --git a/server/utils/score-api.test.ts b/server/utils/score-api.test.ts
new file mode 100644
index 00000000..e95857ac
--- /dev/null
+++ b/server/utils/score-api.test.ts
@@ -0,0 +1,276 @@
+import type { ScoreVersion } from './drizzle'
+import { describe, expect, it } from 'vitest'
+import { mainQuerySchema } from './schemas'
+import {
+  deriveMarkerScoreStatus,
+  resolveScoreVersion,
+  selectScoreHistory,
+  toScoreApiValue,
+} from './score-api'
+
+function score(
+  epochNumber: number,
+  scoreVersion: ScoreVersion,
+  overrides: Record<string, number | string | null> = {},
+) {
+  return {
+    validatorId: 7,
+    epochNumber,
+    scoreVersion,
+    total: 0.9,
+    availability: 0.8,
+    recentAvailability: scoreVersion === 2 ? 0.75 : null,
+    longTermAvailability: scoreVersion === 2 ? 0.85 : null,
+    dominance: 0.7,
+    reliability: 0.95,
+    dataStatus: 'complete' as const,
+    longTermCoverage: scoreVersion === 2 ? 0.6 : null,
+    longTermAsOfEpoch: scoreVersion === 2 ? epochNumber - 1 : null,
+    ...overrides,
+  }
+}
+
+describe('score API version selection', () => {
+  it('parses only score versions 1 and 2', () => {
+    expect(mainQuerySchema.parse({ 'score-version': '1' })['score-version']).toBe(1)
+    expect(mainQuerySchema.parse({ 'score-version': '2' })['score-version']).toBe(2)
+    expect(() => mainQuerySchema.parse({ 'score-version': '3' })).toThrow()
+  })
+
+  it('uses v1 by default in off and shadow modes, and v2 in active mode', () => {
+    expect(resolveScoreVersion(undefined, 'off')).toBe(1)
+    expect(resolveScoreVersion(undefined, 'shadow')).toBe(1)
+    expect(resolveScoreVersion(undefined, 'active')).toBe(2)
+    expect(resolveScoreVersion(2, 'off')).toBe(2)
+    expect(resolveScoreVersion(1, 'active')).toBe(1)
+  })
+})
+
+describe('score API value mapping', () => {
+  it('marks an exact score current and an older selected-version score stale', () => {
+    expect(toScoreApiValue(score(20, 2), {
+      requestedEpoch: 20,
+      scoreVersion: 2,
+      recentCoverage: 1,
+    })).toMatchObject({
+      scoreVersion: 2,
+      epochNumber: 20,
+      scoreEpoch: 20,
+      dataStatus: 'current',
+      recentCoverage: 1,
+    })
+
+    expect(toScoreApiValue(score(19, 2), {
+      requestedEpoch: 20,
+      scoreVersion: 2,
+      recentCoverage: 0.8,
+    })).toMatchObject({
+      scoreVersion: 2,
+      epochNumber: 19,
+      scoreEpoch: 19,
+      dataStatus: 'stale',
+      recentCoverage: 0.8,
+    })
+  })
+
+  it('keeps an exact-epoch row stale when its stored data is stale', () => {
+    expect(toScoreApiValue(score(20, 2, {
+      dataStatus: 'stale',
+    }), {
+      requestedEpoch: 20,
+      scoreVersion: 2,
+      recentCoverage: 1,
+    })).toMatchObject({
+      epochNumber: 20,
+      scoreEpoch: 20,
+      dataStatus: 'stale',
+    })
+  })
+
+  it('returns explicit no_score data without coercing missing values to zero', () => {
+    expect(toScoreApiValue(null, {
+      requestedEpoch: 20,
+      scoreVersion: 2,
+      recentCoverage: 0.75,
+    })).toEqual({
+      scoreVersion: 2,
+      total: null,
+      availability: null,
+      recentAvailability: null,
+      longTermAvailability: null,
+      dominance: null,
+      reliability: null,
+      epochNumber: null,
+      scoreEpoch: null,
+      dataStatus: 'no_score',
+      recentCoverage: 0.75,
+      longTermCoverage: null,
+      longTermAsOfEpoch: null,
+    })
+  })
+
+  it('preserves nullable score components', () => {
+    expect(toScoreApiValue(score(20, 2, {
+      recentAvailability: null,
+      longTermAvailability: null,
+      longTermCoverage: null,
+      longTermAsOfEpoch: null,
+    }), {
+      requestedEpoch: 20,
+      scoreVersion: 2,
+      recentCoverage: 1,
+    })).toMatchObject({
+      recentAvailability: null,
+      longTermAvailability: null,
+      longTermCoverage: null,
+      longTermAsOfEpoch: null,
+    })
+  })
+})
+
+describe('score API history selection', () => {
+  it('keeps one requested version and sorts history by epoch ascending', () => {
+    expect(selectScoreHistory([
+      score(12, 2),
+      score(11, 1),
+      score(10, 2),
+      score(9, 1),
+    ], 2).map(row => [row.epochNumber, row.scoreVersion])).toEqual([
+      [10, 2],
+      [12, 2],
+    ])
+  })
+})
+
+describe('marker-derived score status', () => {
+  const markers = [
+    {
+      epochNumber: 10,
+      status: 'finalized' as const,
+      startedAt: '2026-07-29T08:00:00.000Z',
+      finalizedAt: '2026-07-29T08:05:00.000Z',
+      lastError: null,
+    },
+    {
+      epochNumber: 11,
+      status: 'failed' as const,
+      startedAt: '2026-07-29T08:00:00.000Z',
+      finalizedAt: null,
+      lastError: 'RPC unavailable',
+    },
+    {
+      epochNumber: 12,
+      status: 'syncing' as const,
+      startedAt: '2026-07-29T08:00:00.000Z',
+      finalizedAt: null,
+      lastError: null,
+    },
+    {
+      epochNumber: 13,
+      status: 'finalized' as const,
+      startedAt: '2026-07-29T08:00:00.000Z',
+      finalizedAt: '2026-07-29T08:05:00.000Z',
+      lastError: null,
+    },
+    {
+      epochNumber: 14,
+      status: 'finalized' as const,
+      startedAt: '2026-07-29T08:00:00.000Z',
+      finalizedAt: '2026-07-29T08:05:00.000Z',
+      lastError: null,
+    },
+  ]
+
+  it('reports exact coverage, marker gaps, entries, and selected-version freshness', () => {
+    const status = deriveMarkerScoreStatus({
+      markers,
+      recentRange: { fromEpoch: 12, toEpoch: 14 },
+      longTermRange: { fromEpoch: 10, toEpoch: 14 },
+      activeScoreVersion: 2,
+      selectedScoreVersion: 2,
+      latestScore: { epochNumber: 13, dataStatus: 'complete' },
+    })
+
+    expect(status).toMatchObject({
+      latestCompletedEpoch: 14,
+      latestFinalizedEpoch: 14,
+      recentCoverage: 2 / 3,
+      longTermCoverage: 3 / 5,
+      activeScoreVersion: 2,
+      selectedScoreVersion: 2,
+      latestScoreEpoch: 13,
+      scoreStatus: 'stale',
+      missingEpochs: [11, 12],
+    })
+    expect(status.failedEpochs).toEqual([
+      expect.objectContaining({ epochNumber: 11, lastError: 'RPC unavailable' }),
+    ])
+    expect(status.syncingEpochs).toEqual([
+      expect.objectContaining({ epochNumber: 12 }),
+    ])
+  })
+
+  it('reports current and no_score without inventing an epoch', () => {
+    const input = {
+      markers,
+      recentRange: { fromEpoch: 12, toEpoch: 14 },
+      longTermRange: { fromEpoch: 10, toEpoch: 14 },
+      activeScoreVersion: 2 as const,
+      selectedScoreVersion: 2 as const,
+    }
+
+    expect(deriveMarkerScoreStatus({
+      ...input,
+      latestScore: { epochNumber: 14, dataStatus: 'complete' },
+    })).toMatchObject({
+      latestScoreEpoch: 14,
+      scoreStatus: 'current',
+    })
+    expect(deriveMarkerScoreStatus({ ...input, latestScore: null })).toMatchObject({
+      latestScoreEpoch: null,
+      scoreStatus: 'no_score',
+    })
+  })
+
+  it('keeps selected score status stale when an exact-epoch row is persisted stale', () => {
+    expect(deriveMarkerScoreStatus({
+      markers,
+      recentRange: { fromEpoch: 12, toEpoch: 14 },
+      longTermRange: { fromEpoch: 10, toEpoch: 14 },
+      activeScoreVersion: 2,
+      selectedScoreVersion: 2,
+      latestScore: { epochNumber: 14, dataStatus: 'stale' },
+    })).toMatchObject({
+      latestCompletedEpoch: 14,
+      latestScoreEpoch: 14,
+      scoreStatus: 'stale',
+    })
+  })
+
+  it('keeps stored marker and score state when live ranges are unavailable', () => {
+    expect(deriveMarkerScoreStatus({
+      markers,
+      recentRange: null,
+      longTermRange: null,
+      activeScoreVersion: 1,
+      selectedScoreVersion: 2,
+      latestScore: { epochNumber: 13, dataStatus: 'complete' },
+    })).toMatchObject({
+      latestCompletedEpoch: 14,
+      latestFinalizedEpoch: 14,
+      recentCoverage: null,
+      longTermCoverage: null,
+      activeScoreVersion: 1,
+      selectedScoreVersion: 2,
+      latestScoreEpoch: 13,
+      scoreStatus: 'stale',
+      missingEpochs: null,
+      failedEpochs: [
+        expect.objectContaining({ epochNumber: 11, lastError: 'RPC unavailable' }),
+      ],
+      syncingEpochs: [
+        expect.objectContaining({ epochNumber: 12 }),
+      ],
+    })
+  })
+})
diff --git a/server/utils/score-api.ts b/server/utils/score-api.ts
new file mode 100644
index 00000000..ced6b3ff
--- /dev/null
+++ b/server/utils/score-api.ts
@@ -0,0 +1,183 @@
+import type { ActivityEpoch, Score, ScoreVersion } from './drizzle'
+import type { ScoreApiValue } from './types'
+
+export type ScoreRolloutMode = 'off' | 'shadow' | 'active'
+export type ScoreFreshness = ScoreApiValue['dataStatus']
+
+export interface ScoreApiOptions {
+  requestedEpoch: number
+  scoreVersion: ScoreVersion
+  recentCoverage: number
+}
+
+export type ScoreApiSource = Pick<
+  Score,
+  | 'availability'
+  | 'dataStatus'
+  | 'dominance'
+  | 'epochNumber'
+  | 'longTermAsOfEpoch'
+  | 'longTermAvailability'
+  | 'longTermCoverage'
+  | 'recentAvailability'
+  | 'reliability'
+  | 'scoreVersion'
+  | 'total'
+>
+
+export type MarkerScoreStatusEntry = Pick<
+  ActivityEpoch,
+  'epochNumber' | 'finalizedAt' | 'lastError' | 'startedAt' | 'status'
+>
+
+export interface MarkerScoreStatusInput {
+  markers: readonly MarkerScoreStatusEntry[]
+  recentRange: {
+    fromEpoch: number
+    toEpoch: number
+  } | null
+  longTermRange: {
+    fromEpoch: number
+    toEpoch: number
+  } | null
+  activeScoreVersion: ScoreVersion
+  selectedScoreVersion: ScoreVersion
+  latestScore: Pick<Score, 'epochNumber' | 'dataStatus'> | null
+}
+
+export interface MarkerScoreStatus {
+  latestCompletedEpoch: number | null
+  latestFinalizedEpoch: number | null
+  recentCoverage: number | null
+  longTermCoverage: number | null
+  activeScoreVersion: ScoreVersion
+  selectedScoreVersion: ScoreVersion
+  latestScoreEpoch: number | null
+  scoreStatus: ScoreFreshness
+  missingEpochs: number[] | null
+  failedEpochs: MarkerScoreStatusEntry[]
+  syncingEpochs: MarkerScoreStatusEntry[]
+}
+
+export function resolveScoreVersion(
+  requestedVersion: ScoreVersion | undefined,
+  rolloutMode: ScoreRolloutMode,
+): ScoreVersion {
+  if (requestedVersion !== undefined)
+    return requestedVersion
+
+  switch (rolloutMode) {
+    case 'off':
+    case 'shadow':
+      return 1
+    case 'active':
+      return 2
+    default:
+      throw new Error(`Invalid score v2 mode: ${String(rolloutMode)}`)
+  }
+}
+
+export function toScoreApiValue(
+  score: ScoreApiSource | null,
+  options: ScoreApiOptions,
+): ScoreApiValue {
+  if (!score) {
+    return {
+      scoreVersion: options.scoreVersion,
+      total: null,
+      availability: null,
+      recentAvailability: null,
+      longTermAvailability: null,
+      dominance: null,
+      reliability: null,
+      epochNumber: null,
+      scoreEpoch: null,
+      dataStatus: 'no_score',
+      recentCoverage: options.recentCoverage,
+      longTermCoverage: null,
+      longTermAsOfEpoch: null,
+    }
+  }
+
+  return {
+    scoreVersion: score.scoreVersion,
+    total: score.total,
+    availability: score.availability,
+    recentAvailability: score.recentAvailability,
+    longTermAvailability: score.longTermAvailability,
+    dominance: score.dominance,
+    reliability: score.reliability,
+    epochNumber: score.epochNumber,
+    scoreEpoch: score.epochNumber,
+    dataStatus: score.epochNumber === options.requestedEpoch && score.dataStatus === 'complete'
+      ? 'current'
+      : 'stale',
+    recentCoverage: options.recentCoverage,
+    longTermCoverage: score.longTermCoverage,
+    longTermAsOfEpoch: score.longTermAsOfEpoch,
+  }
+}
+
+export function selectScoreHistory<
+  T extends Pick<Score, 'epochNumber' | 'scoreVersion'>,
+>(scores: readonly T[], scoreVersion: ScoreVersion): T[] {
+  return scores
+    .filter(score => score.scoreVersion === scoreVersion)
+    .sort((a, b) => a.epochNumber - b.epochNumber)
+}
+
+export function deriveMarkerScoreStatus(
+  input: MarkerScoreStatusInput,
+): MarkerScoreStatus {
+  const finalizedEpochs = input.markers
+    .filter(marker => marker.status === 'finalized')
+    .map(marker => marker.epochNumber)
+  const finalizedSet = new Set(finalizedEpochs)
+  const completedEpochs = input.markers.map(marker => marker.epochNumber)
+  const latestCompletedEpoch = completedEpochs.length > 0 ? Math.max(...completedEpochs) : null
+  const coverage = (fromEpoch: number, toEpoch: number) => {
+    const expectedEpochCount = toEpoch - fromEpoch + 1
+    let finalizedEpochCount = 0
+    for (let epochNumber = fromEpoch; epochNumber <= toEpoch; epochNumber++) {
+      if (finalizedSet.has(epochNumber))
+        finalizedEpochCount++
+    }
+    return expectedEpochCount > 0 ? finalizedEpochCount / expectedEpochCount : 0
+  }
+  let missingEpochs: number[] | null = null
+  if (input.longTermRange) {
+    missingEpochs = []
+    for (
+      let epochNumber = input.longTermRange.fromEpoch;
+      epochNumber <= input.longTermRange.toEpoch;
+      epochNumber++
+    ) {
+      if (!finalizedSet.has(epochNumber))
+        missingEpochs.push(epochNumber)
+    }
+  }
+
+  return {
+    latestCompletedEpoch,
+    latestFinalizedEpoch: finalizedEpochs.length > 0 ? Math.max(...finalizedEpochs) : null,
+    recentCoverage: input.recentRange
+      ? coverage(input.recentRange.fromEpoch, input.recentRange.toEpoch)
+      : null,
+    longTermCoverage: input.longTermRange
+      ? coverage(input.longTermRange.fromEpoch, input.longTermRange.toEpoch)
+      : null,
+    activeScoreVersion: input.activeScoreVersion,
+    selectedScoreVersion: input.selectedScoreVersion,
+    latestScoreEpoch: input.latestScore?.epochNumber ?? null,
+    scoreStatus: input.latestScore === null
+      ? 'no_score'
+      : latestCompletedEpoch !== null
+        && input.latestScore.epochNumber === latestCompletedEpoch
+        && input.latestScore.dataStatus === 'complete'
+        ? 'current'
+        : 'stale',
+    missingEpochs,
+    failedEpochs: input.markers.filter(marker => marker.status === 'failed'),
+    syncingEpochs: input.markers.filter(marker => marker.status === 'syncing'),
+  }
+}
diff --git a/server/utils/scores.integration.test.ts b/server/utils/scores.integration.test.ts
new file mode 100644
index 00000000..963645cf
--- /dev/null
+++ b/server/utils/scores.integration.test.ts
@@ -0,0 +1,647 @@
+import type { Range } from 'nimiq-validator-trustscore/types'
+import type { TestDbHarness } from '../test/db-harness'
+import { and, asc, eq } from 'drizzle-orm'
+import { afterAll, afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import * as schema from '../db/schema'
+import { createTestDbHarness } from '../test/db-harness'
+
+const drizzleState = vi.hoisted(() => ({ db: undefined as unknown }))
+const runtimeConfigState = vi.hoisted(() => ({ scoreV2Mode: 'off' }))
+const mocks = vi.hoisted(() => ({
+  getRange: vi.fn(),
+  getStoredValidatorsId: vi.fn(),
+}))
+
+vi.mock('nimiq-validator-trustscore/range', () => ({
+  getRange: mocks.getRange,
+}))
+
+vi.mock('./validators', () => ({
+  getStoredValidatorsId: mocks.getStoredValidatorsId,
+}))
+
+vi.mock('./drizzle', () => ({
+  tables: schema,
+  useDrizzle: () => drizzleState.db,
+}))
+
+vi.stubGlobal('tables', schema)
+vi.stubGlobal('useDrizzle', () => drizzleState.db)
+vi.stubGlobal('useSafeRuntimeConfig', () => ({
+  scoreV2Mode: runtimeConfigState.scoreV2Mode,
+  public: {
+    nimiqNetwork: 'testnet',
+    scoreV2Mode: runtimeConfigState.scoreV2Mode,
+  },
+}))
+
+type ScoresModule = typeof import('./scores')
+
+let scores: ScoresModule
+let harness: TestDbHarness
+
+function createRange(fromEpoch: number, toEpoch: number): Range {
+  return {
+    head: 1_000_000,
+    headEpoch: toEpoch + 1,
+    epochCount: toEpoch - fromEpoch + 1,
+    epochDurationMs: 12 * 60 * 60 * 1000,
+    fromEpoch,
+    fromBlockNumber: 0,
+    fromTimestamp: 0,
+    toEpoch,
+    toBlockNumber: 999_999,
+    toTimestamp: 0,
+    snapshotEpoch: toEpoch + 1,
+    snapshotBlock: 1_000_000,
+    snapshotTimestamp: 0,
+  }
+}
+
+async function insertValidators(count: number, prefix = 'score-validator') {
+  return harness.db.insert(schema.validators).values(Array.from({ length: count }, (_, index) => ({
+    address: `${prefix}-${index.toString().padStart(3, '0')}`,
+    name: 'Score validator',
+    logo: 'test-logo',
+    hasDefaultLogo: true,
+    accentColor: '#000000',
+  }))).returning({
+    id: schema.validators.id,
+    address: schema.validators.address,
+  }).all()
+}
+
+function finalizedMarker(epochNumber: number, validatorCount: number) {
+  return {
+    epochNumber,
+    status: 'finalized' as const,
+    expectedElectedCount: validatorCount,
+    storedElectedCount: validatorCount,
+    electedSetHash: `marker-${epochNumber}`,
+    attemptCount: 1,
+    startedAt: '2026-07-28T08:00:00.000Z',
+    finalizedAt: '2026-07-28T08:05:00.000Z',
+    lastError: null,
+  }
+}
+
+function activityRow(
+  validatorId: number,
+  epochNumber: number,
+  rewarded = 720,
+  missed = 0,
+  overrides: Record<string, number> = {},
+) {
+  return {
+    validatorId,
+    epochNumber,
+    likelihood: 1,
+    rewarded,
+    missed,
+    dominanceRatioViaBalance: 0,
+    dominanceRatioViaSlots: 0,
+    balance: 1_000,
+    stakers: 1,
+    ...overrides,
+  }
+}
+
+async function insertFinalizedRange(
+  fromEpoch: number,
+  toEpoch: number,
+  validatorCount = 1,
+) {
+  await harness.db.insert(schema.activityEpochs).values(
+    Array.from(
+      { length: toEpoch - fromEpoch + 1 },
+      (_, index) => finalizedMarker(fromEpoch + index, validatorCount),
+    ),
+  ).execute()
+}
+
+beforeEach(async () => {
+  harness = await createTestDbHarness()
+  drizzleState.db = harness.db
+  runtimeConfigState.scoreV2Mode = 'off'
+  mocks.getRange.mockReset()
+  mocks.getStoredValidatorsId.mockReset()
+  mocks.getStoredValidatorsId.mockImplementation(() => harness.db
+    .select({ id: schema.validators.id })
+    .from(schema.validators)
+    .execute()
+    .then(rows => rows.map(row => row.id)))
+
+  vi.resetModules()
+  scores = await import('./scores')
+})
+
+afterEach(() => {
+  harness.close()
+  drizzleState.db = undefined
+})
+
+afterAll(() => {
+  vi.unstubAllGlobals()
+})
+
+describe('marker-gated v1 score persistence', () => {
+  it('preserves prior scores and returns stale when any required activity marker is incomplete', async () => {
+    const range = createRange(10, 11)
+    const [validator] = await insertValidators(1)
+    runtimeConfigState.scoreV2Mode = 'shadow'
+    mocks.getRange.mockResolvedValue([true, undefined, range])
+    await harness.db.insert(schema.activity).values([
+      activityRow(validator!.id, 10),
+      activityRow(validator!.id, 11),
+    ]).execute()
+    await harness.db.insert(schema.activityEpochs).values([
+      finalizedMarker(10, 1),
+      {
+        epochNumber: 11,
+        status: 'syncing',
+        attemptCount: 1,
+        startedAt: '2026-07-28T08:00:00.000Z',
+      },
+    ]).execute()
+    await harness.db.insert(schema.scores).values([
+      {
+        validatorId: validator!.id,
+        epochNumber: 9,
+        scoreVersion: 1,
+        total: 0.75,
+        availability: 0.8,
+        dominance: 0.95,
+        reliability: 0.99,
+        dataStatus: 'complete',
+      },
+      {
+        validatorId: validator!.id,
+        epochNumber: 9,
+        scoreVersion: 2,
+        total: 0.7,
+        availability: 0.75,
+        recentAvailability: 0.7,
+        longTermAvailability: 0.8,
+        dominance: 0.95,
+        reliability: 0.98,
+        dataStatus: 'complete',
+        longTermCoverage: 1,
+        longTermAsOfEpoch: 9,
+      },
+    ]).execute()
+    const scoresBefore = await harness.db.select().from(schema.scores).all()
+
+    const result = await scores.upsertScoresSnapshotEpoch()
+
+    expect(result).toEqual([true, undefined, expect.objectContaining({
+      dataStatus: 'stale',
+      missingEpochs: [11],
+      scores: [],
+    })])
+    expect(await harness.db.select().from(schema.scores).all()).toEqual(scoresBefore)
+  })
+
+  it('bulk-loads 512 validators and their activity before bounded in-memory scoring and chunked writes', async () => {
+    const epochNumber = 20
+    const range = createRange(epochNumber, epochNumber)
+    const validators = await insertValidators(512, 'bulk-score-validator')
+    mocks.getRange.mockResolvedValue([true, undefined, range])
+    await harness.db.insert(schema.activity).values(validators.map(validator => activityRow(validator.id, epochNumber))).execute()
+    await harness.db.insert(schema.activityEpochs).values(finalizedMarker(epochNumber, validators.length)).execute()
+    harness.trace.reset()
+
+    const result = await scores.upsertScoresSnapshotEpoch()
+
+    expect(result[0]).toBe(true)
+    const tracedStatements = [
+      ...harness.trace.executed,
+      ...harness.trace.batches.flat(),
+    ]
+    const validatorReads = tracedStatements.filter(sql => /from\s+[`"]?validators[`"]?(?:\s|$)/i.test(sql))
+    const activityReads = tracedStatements.filter(sql => /from\s+[`"]?activity[`"]?(?:\s|$)/i.test(sql))
+    const scoreInserts = tracedStatements.filter(sql => /insert\s+into\s+[`"]?scores[`"]?(?:\s|\()/i.test(sql))
+    expect(validatorReads.length).toBeLessThanOrEqual(1)
+    expect(activityReads.length).toBeLessThanOrEqual(2)
+    expect(scoreInserts.length).toBeLessThanOrEqual(Math.ceil(validators.length / 5))
+    expect(tracedStatements.length).toBeLessThan(200)
+    expect(await harness.db.select().from(schema.scores).all()).toHaveLength(validators.length)
+  }, 60_000)
+
+  it('keeps current v1 numeric semantics for complete marker-backed activity', async () => {
+    const range = createRange(1, 2)
+    const [perfectValidator, intermittentValidator] = await insertValidators(2, 'semantic-score-validator')
+    mocks.getRange.mockResolvedValue([true, undefined, range])
+    await harness.db.insert(schema.activityEpochs).values([
+      finalizedMarker(1, 2),
+      finalizedMarker(2, 2),
+    ]).execute()
+    await harness.db.insert(schema.activity).values([
+      activityRow(perfectValidator!.id, 1),
+      activityRow(perfectValidator!.id, 2),
+      activityRow(intermittentValidator!.id, 1),
+      activityRow(intermittentValidator!.id, 2, 0, 0),
+    ]).execute()
+
+    const result = await scores.upsertScoresSnapshotEpoch()
+
+    expect(result[0]).toBe(true)
+    const calculated = result[2]!.scores.sort((a, b) => a.validatorId - b.validatorId)
+    expect(calculated[0]).toMatchObject({
+      validatorId: perfectValidator!.id,
+      epochNumber: 2,
+      scoreVersion: 1,
+    })
+    expect(calculated[0]!.availability).toBeCloseTo(1, 12)
+    expect(calculated[0]!.dominance).toBeCloseTo(1, 12)
+    expect(calculated[0]!.reliability).toBeCloseTo(1, 12)
+    expect(calculated[0]!.total).toBeCloseTo(1, 12)
+    expect(calculated[1]).toMatchObject({
+      validatorId: intermittentValidator!.id,
+      epochNumber: 2,
+      scoreVersion: 1,
+    })
+    expect(calculated[1]!.dominance).toBeCloseTo(1, 12)
+    expect(calculated[1]!.reliability).toBeCloseTo(1, 12)
+    expect(calculated[1]!.availability).toBeCloseTo(40 / 49, 12)
+    expect(calculated[1]!.total).toBeCloseTo(40 / 49, 12)
+    expect(calculated[1]!.params.availability.activeEpochStates).toEqual([1, 0])
+    expect(Array.from(calculated[1]!.params.reliability.inherentsPerEpoch.entries())).toEqual([
+      [1, { rewarded: 720, missed: 0 }],
+      [2, { rewarded: 0, missed: 0 }],
+    ])
+    const storedScores = await harness.db.select().from(schema.scores).orderBy(asc(schema.scores.validatorId)).all()
+    expect(storedScores[0]).toMatchObject({ validatorId: perfectValidator!.id })
+    expect(storedScores[0]!.total).toBeCloseTo(1, 12)
+    expect(storedScores[1]).toMatchObject({ validatorId: intermittentValidator!.id })
+    expect(storedScores[1]!.total).toBeCloseTo(40 / 49, 12)
+  })
+})
+
+describe('score v2 rollout persistence', () => {
+  it('writes coexisting v1 and v2 rows in shadow mode and reruns idempotently', async () => {
+    const range = createRange(10, 11)
+    const [validator] = await insertValidators(1, 'shadow-score-validator')
+    runtimeConfigState.scoreV2Mode = 'shadow'
+    mocks.getRange.mockResolvedValue([true, undefined, range])
+    await insertFinalizedRange(10, 11)
+    await harness.db.insert(schema.activity).values([
+      activityRow(validator!.id, 10),
+      activityRow(validator!.id, 11),
+    ]).execute()
+
+    expect((await scores.upsertScoresSnapshotEpoch())[0]).toBe(true)
+    expect((await scores.upsertScoresSnapshotEpoch())[0]).toBe(true)
+
+    const stored = await harness.db.select()
+      .from(schema.scores)
+      .where(eq(schema.scores.epochNumber, 11))
+      .orderBy(asc(schema.scores.scoreVersion))
+      .all()
+    expect(stored).toHaveLength(2)
+    expect(stored.map(score => score.scoreVersion)).toEqual([1, 2])
+    expect(stored[1]).toMatchObject({
+      validatorId: validator!.id,
+      epochNumber: 11,
+      scoreVersion: 2,
+      dataStatus: 'complete',
+      recentAvailability: 1,
+      longTermAvailability: 1,
+      longTermCoverage: 1,
+      longTermAsOfEpoch: 11,
+    })
+  })
+
+  it('writes only v1 while score v2 mode is off', async () => {
+    const range = createRange(20, 20)
+    const [validator] = await insertValidators(1, 'off-score-validator')
+    runtimeConfigState.scoreV2Mode = 'off'
+    mocks.getRange.mockResolvedValue([true, undefined, range])
+    await insertFinalizedRange(20, 20)
+    await harness.db.insert(schema.activity).values(activityRow(validator!.id, 20)).execute()
+
+    expect((await scores.upsertScoresSnapshotEpoch())[0]).toBe(true)
+
+    const stored = await harness.db.select().from(schema.scores).all()
+    expect(stored).toHaveLength(1)
+    expect(stored[0]).toMatchObject({
+      validatorId: validator!.id,
+      epochNumber: 20,
+      scoreVersion: 1,
+    })
+  })
+
+  it('retains trustworthy long-term state when recent coverage is complete but long-term coverage is partial', async () => {
+    const range = createRange(1, 40)
+    const [validator] = await insertValidators(1, 'retained-score-validator')
+    runtimeConfigState.scoreV2Mode = 'shadow'
+    mocks.getRange.mockResolvedValue([true, undefined, range])
+    await insertFinalizedRange(12, 40)
+    await harness.db.insert(schema.activity).values(
+      Array.from(
+        { length: 29 },
+        (_, index) => activityRow(validator!.id, 12 + index),
+      ),
+    ).execute()
+    await harness.db.insert(schema.scores).values({
+      validatorId: validator!.id,
+      epochNumber: 39,
+      scoreVersion: 2,
+      total: 0.7,
+      availability: 0.85,
+      recentAvailability: 0.9,
+      longTermAvailability: 0.8,
+      dominance: 1,
+      reliability: 0.9,
+      dataStatus: 'complete',
+      longTermCoverage: 1,
+      longTermAsOfEpoch: 11,
+    }).execute()
+
+    expect((await scores.upsertScoresSnapshotEpoch())[0]).toBe(true)
+
+    const stored = await harness.db.select().from(schema.scores).where(and(
+      eq(schema.scores.validatorId, validator!.id),
+      eq(schema.scores.epochNumber, 40),
+      eq(schema.scores.scoreVersion, 2),
+    )).get()
+    expect(stored).toMatchObject({
+      recentAvailability: 1,
+      longTermAvailability: 0.8,
+      reliability: 0.9,
+      longTermAsOfEpoch: 11,
+      dataStatus: 'complete',
+    })
+    expect(stored!.longTermCoverage).toBeCloseTo(29 / 40, 12)
+    expect(stored!.availability).toBeCloseTo(0.9, 12)
+    expect(stored!.total).toBeCloseTo(0.81, 12)
+  })
+
+  it('ignores positive dominance from an unfinalized epoch when retaining long-term state', async () => {
+    const range = createRange(1, 40)
+    const [validator] = await insertValidators(1, 'finalized-dominance-validator')
+    runtimeConfigState.scoreV2Mode = 'shadow'
+    mocks.getRange.mockResolvedValue([true, undefined, range])
+    await insertFinalizedRange(12, 40)
+    await harness.db.insert(schema.activityEpochs).values({
+      epochNumber: 11,
+      status: 'syncing',
+      attemptCount: 1,
+      startedAt: '2026-07-28T08:00:00.000Z',
+    }).execute()
+    await harness.db.insert(schema.activity).values([
+      activityRow(validator!.id, 11, 720, 0, {
+        dominanceRatioViaBalance: 1,
+        dominanceRatioViaSlots: 1,
+      }),
+      ...Array.from(
+        { length: 29 },
+        (_, index) => activityRow(validator!.id, 12 + index, 720, 0, {
+          dominanceRatioViaBalance: -1,
+          dominanceRatioViaSlots: -1,
+        }),
+      ),
+    ]).execute()
+    await harness.db.insert(schema.scores).values({
+      validatorId: validator!.id,
+      epochNumber: 39,
+      scoreVersion: 2,
+      total: 0.7,
+      availability: 0.85,
+      recentAvailability: 0.9,
+      longTermAvailability: 0.8,
+      dominance: 1,
+      reliability: 0.9,
+      dataStatus: 'complete',
+      longTermCoverage: 1,
+      longTermAsOfEpoch: 10,
+    }).execute()
+
+    expect((await scores.upsertScoresSnapshotEpoch())[0]).toBe(true)
+
+    const stored = await harness.db.select().from(schema.scores).where(and(
+      eq(schema.scores.validatorId, validator!.id),
+      eq(schema.scores.epochNumber, 40),
+      eq(schema.scores.scoreVersion, 2),
+    )).get()
+    expect(stored).toMatchObject({
+      dominance: 1,
+      recentAvailability: 1,
+      longTermAvailability: 0.8,
+      reliability: 0.9,
+      longTermAsOfEpoch: 10,
+    })
+    expect(stored!.total).toBeCloseTo(0.81, 12)
+  })
+
+  it('publishes no current v2 row when long-term coverage is partial and no prior v2 state exists', async () => {
+    const range = createRange(1, 40)
+    const [validator] = await insertValidators(1, 'no-prior-score-validator')
+    runtimeConfigState.scoreV2Mode = 'shadow'
+    mocks.getRange.mockResolvedValue([true, undefined, range])
+    await insertFinalizedRange(12, 40)
+    await harness.db.insert(schema.activity).values(
+      Array.from(
+        { length: 29 },
+        (_, index) => activityRow(validator!.id, 12 + index),
+      ),
+    ).execute()
+
+    expect((await scores.upsertScoresSnapshotEpoch())[0]).toBe(true)
+
+    const stored = await harness.db.select().from(schema.scores).where(and(
+      eq(schema.scores.validatorId, validator!.id),
+      eq(schema.scores.epochNumber, 40),
+    )).all()
+    expect(stored).toHaveLength(1)
+    expect(stored[0]!.scoreVersion).toBe(1)
+  })
+
+  it('backfills validators missing v2 inside a partially populated historical score epoch', async () => {
+    const range = createRange(40, 42)
+    const [validatorA, validatorB] = await insertValidators(2, 'partial-backfill-validator')
+    runtimeConfigState.scoreV2Mode = 'shadow'
+    mocks.getRange.mockResolvedValue([true, undefined, range])
+    await insertFinalizedRange(39, 42, 2)
+    await harness.db.insert(schema.activity).values(
+      [39, 40, 41, 42].flatMap(epochNumber => [
+        activityRow(validatorA!.id, epochNumber),
+        activityRow(validatorB!.id, epochNumber),
+      ]),
+    ).execute()
+    await harness.db.insert(schema.scores).values([
+      {
+        validatorId: validatorA!.id,
+        epochNumber: 41,
+        scoreVersion: 1,
+        total: 1,
+        availability: 1,
+        dominance: 1,
+        reliability: 1,
+      },
+      {
+        validatorId: validatorB!.id,
+        epochNumber: 41,
+        scoreVersion: 1,
+        total: 1,
+        availability: 1,
+        dominance: 1,
+        reliability: 1,
+      },
+      {
+        validatorId: validatorA!.id,
+        epochNumber: 41,
+        scoreVersion: 2,
+        total: 0.7,
+        availability: 0.8,
+        recentAvailability: 0.8,
+        longTermAvailability: 0.8,
+        dominance: 1,
+        reliability: 0.875,
+        longTermCoverage: 1,
+        longTermAsOfEpoch: 41,
+      },
+    ]).execute()
+
+    const progress: string[] = []
+    const [success, error, result] = await scores.upsertScoresSnapshotEpoch({
+      onProgress: message => progress.push(message),
+    })
+
+    expect(success).toBe(true)
+    expect(error).toBeUndefined()
+    expect(result!.backfilledEpochs).toEqual([41])
+    expect(progress).toEqual(expect.arrayContaining([
+      'range 40-42; v2 mode shadow',
+      'loaded 2 validator(s), 6 activity row(s)',
+      'calculating current v1 for 2 validator(s) at epoch 42',
+      'stored current v1 rows 2/2',
+      'calculating current v2 for 2 validator(s) at epoch 42',
+      'stored current v2 rows 2/2',
+      'backfill found 1 candidate epoch(s)',
+      'backfill epoch 41 (1/1): checking coverage',
+      'backfill epoch 41 (1/1): calculating 1 validator(s)',
+      'backfill epoch 41 (1/1): prepared 1 score(s)',
+      'stored v2 backfill rows 1/1',
+    ]))
+    const historicalV2 = await harness.db.select().from(schema.scores).where(and(
+      eq(schema.scores.epochNumber, 41),
+      eq(schema.scores.scoreVersion, 2),
+    )).orderBy(asc(schema.scores.validatorId)).all()
+    expect(historicalV2.map(score => score.validatorId)).toEqual([
+      validatorA!.id,
+      validatorB!.id,
+    ])
+  })
+
+  it('fails without score writes when a finalized epoch contains a placeholder', async () => {
+    const range = createRange(50, 50)
+    const [validator] = await insertValidators(1, 'placeholder-score-validator')
+    runtimeConfigState.scoreV2Mode = 'shadow'
+    mocks.getRange.mockResolvedValue([true, undefined, range])
+    await insertFinalizedRange(50, 50)
+    await harness.db.insert(schema.activity).values(
+      activityRow(validator!.id, 50, -1, -1),
+    ).execute()
+
+    const [success, error] = await scores.upsertScoresSnapshotEpoch()
+
+    expect(success).toBe(false)
+    expect(error).toMatch(/placeholder|integrity/i)
+    expect(await harness.db.select().from(schema.scores).all()).toEqual([])
+  })
+
+  it('rejects a finalized placeholder before writing v1 while score v2 mode is off', async () => {
+    const range = createRange(51, 51)
+    const [validator] = await insertValidators(1, 'off-placeholder-score-validator')
+    runtimeConfigState.scoreV2Mode = 'off'
+    mocks.getRange.mockResolvedValue([true, undefined, range])
+    await insertFinalizedRange(51, 51)
+    await harness.db.insert(schema.activity).values(
+      activityRow(validator!.id, 51, -1, -1),
+    ).execute()
+
+    const [success, error] = await scores.upsertScoresSnapshotEpoch()
+
+    expect(success).toBe(false)
+    expect(error).toMatch(/placeholder|integrity/i)
+    expect(await harness.db.select().from(schema.scores).all()).toEqual([])
+  })
+
+  it('persists current v1 before reporting a non-integrity retained v2 calculation failure', async () => {
+    const range = createRange(1, 40)
+    const [validator] = await insertValidators(1, 'failed-v2-score-validator')
+    runtimeConfigState.scoreV2Mode = 'shadow'
+    mocks.getRange.mockResolvedValue([true, undefined, range])
+    await insertFinalizedRange(12, 40)
+    await harness.db.insert(schema.activity).values(
+      Array.from(
+        { length: 29 },
+        (_, index) => activityRow(validator!.id, 12 + index),
+      ),
+    ).execute()
+    await harness.db.insert(schema.scores).values({
+      validatorId: validator!.id,
+      epochNumber: 39,
+      scoreVersion: 2,
+      total: 0.7,
+      availability: 0.85,
+      recentAvailability: 0.9,
+      longTermAvailability: 2,
+      dominance: 1,
+      reliability: 0.9,
+      dataStatus: 'complete',
+      longTermCoverage: 1,
+      longTermAsOfEpoch: 39,
+    }).execute()
+
+    const [success, error] = await scores.upsertScoresSnapshotEpoch()
+
+    expect(success).toBe(false)
+    expect(error).toMatch(/long-term availability|retained/i)
+    expect(await harness.db.select().from(schema.scores).where(and(
+      eq(schema.scores.validatorId, validator!.id),
+      eq(schema.scores.epochNumber, 40),
+      eq(schema.scores.scoreVersion, 1),
+    )).get()).toMatchObject({
+      validatorId: validator!.id,
+      epochNumber: 40,
+      scoreVersion: 1,
+    })
+    expect(await harness.db.select().from(schema.scores).where(and(
+      eq(schema.scores.validatorId, validator!.id),
+      eq(schema.scores.epochNumber, 40),
+      eq(schema.scores.scoreVersion, 2),
+    )).get()).toBeUndefined()
+  })
+
+  it('returns the latest score epoch for the requested version only', async () => {
+    const [validator] = await insertValidators(1, 'latest-version-score-validator')
+    await harness.db.insert(schema.scores).values([
+      {
+        validatorId: validator!.id,
+        epochNumber: 100,
+        scoreVersion: 1,
+        total: 1,
+        availability: 1,
+        dominance: 1,
+        reliability: 1,
+      },
+      {
+        validatorId: validator!.id,
+        epochNumber: 80,
+        scoreVersion: 2,
+        total: 1,
+        availability: 1,
+        recentAvailability: 1,
+        longTermAvailability: 1,
+        dominance: 1,
+        reliability: 1,
+        longTermCoverage: 1,
+        longTermAsOfEpoch: 80,
+      },
+    ]).execute()
+
+    await expect(scores.getLatestScoreEpoch(1)).resolves.toBe(100)
+    await expect(scores.getLatestScoreEpoch(2)).resolves.toBe(80)
+  })
+})
diff --git a/server/utils/scores.test.ts b/server/utils/scores.test.ts
new file mode 100644
index 00000000..c9fc9be7
--- /dev/null
+++ b/server/utils/scores.test.ts
@@ -0,0 +1,160 @@
+import { describe, expect, it, vi } from 'vitest'
+import {
+  buildScoreV2Epochs,
+  getScoreRollout,
+  parseScoreV2Mode,
+  planV2Backfill,
+  resolveLongTermState,
+} from './scores'
+
+vi.mock('./validators', () => ({
+  getStoredValidatorsId: vi.fn(),
+}))
+
+vi.mock('./drizzle', () => ({
+  tables: {},
+  useDrizzle: () => {
+    throw new Error('Database access is not available in pure score tests')
+  },
+}))
+
+function activity(epoch: number, overrides: Record<string, number> = {}) {
+  return {
+    validatorId: 7,
+    epoch,
+    likelihood: 1,
+    missed: 0,
+    rewarded: 720,
+    dominanceViaSlots: 0.01,
+    dominanceViaBalance: 0.01,
+    balance: 1_000,
+    stakers: 1,
+    ...overrides,
+  }
+}
+
+describe('score v2 rollout mode', () => {
+  it('defaults to off and validates every supported mode', () => {
+    expect(parseScoreV2Mode(undefined)).toBe('off')
+    expect(parseScoreV2Mode('off')).toBe('off')
+    expect(parseScoreV2Mode('shadow')).toBe('shadow')
+    expect(parseScoreV2Mode('active')).toBe('active')
+    expect(() => parseScoreV2Mode('invalid')).toThrow(/score v2 mode/i)
+  })
+
+  it('always writes v1 and activates v2 only in active mode', () => {
+    expect(getScoreRollout('off')).toEqual({
+      writeV1: true,
+      writeV2: false,
+      activeVersion: 1,
+    })
+    expect(getScoreRollout('shadow')).toEqual({
+      writeV1: true,
+      writeV2: true,
+      activeVersion: 1,
+    })
+    expect(getScoreRollout('active')).toEqual({
+      writeV1: true,
+      writeV2: true,
+      activeVersion: 2,
+    })
+  })
+})
+
+describe('score v2 finalized activity mapping', () => {
+  it('maps an absent validator row in a finalized epoch to random non-election', () => {
+    const result = buildScoreV2Epochs({
+      validatorId: 7,
+      range: { fromEpoch: 10, toEpoch: 12 },
+      activities: [
+        activity(10),
+        activity(12, { likelihood: 0, missed: 9, rewarded: 711 }),
+      ],
+    })
+
+    expect(result).toEqual([true, undefined, [
+      expect.objectContaining({ epochNumber: 12, status: 'elected_degraded' }),
+      {
+        epochNumber: 11,
+        status: 'not_elected_randomness',
+        rewarded: -1,
+        missed: -1,
+      },
+      expect.objectContaining({ epochNumber: 10, status: 'elected_online' }),
+    ]])
+  })
+
+  it('rejects a placeholder inside a finalized range', () => {
+    const [success, error, epochs] = buildScoreV2Epochs({
+      validatorId: 7,
+      range: { fromEpoch: 10, toEpoch: 10 },
+      activities: [activity(10, { missed: -1, rewarded: -1 })],
+    })
+
+    expect(success).toBe(false)
+    expect(error).toMatch(/placeholder|integrity/i)
+    expect(epochs).toBeUndefined()
+  })
+})
+
+describe('score v2 retained long-term state', () => {
+  const prior = {
+    longTermAvailability: 0.98,
+    reliability: 0.97,
+    longTermAsOfEpoch: 90,
+  }
+
+  it('uses freshly computed state only at full coverage', () => {
+    expect(resolveLongTermState({
+      coverage: 1,
+      targetEpoch: 100,
+      computed: {
+        longTermAvailability: 0.99,
+        reliability: 0.96,
+      },
+      prior,
+    })).toEqual({
+      longTermAvailability: 0.99,
+      reliability: 0.96,
+      longTermCoverage: 1,
+      longTermAsOfEpoch: 100,
+    })
+  })
+
+  it('retains a trustworthy prior pair when coverage is partial', () => {
+    expect(resolveLongTermState({
+      coverage: 0.75,
+      targetEpoch: 100,
+      prior,
+    })).toEqual({
+      ...prior,
+      longTermCoverage: 0.75,
+    })
+  })
+
+  it('publishes no state without a prior pair or when it comes from the future', () => {
+    expect(resolveLongTermState({
+      coverage: 0.75,
+      targetEpoch: 100,
+    })).toBeNull()
+    expect(resolveLongTermState({
+      coverage: 0.75,
+      targetEpoch: 80,
+      prior,
+    })).toBeNull()
+  })
+})
+
+describe('score v2 backfill planning', () => {
+  it('returns unique missing v2 epochs newest first and bounded', () => {
+    expect(planV2Backfill(
+      [100, 98, 100, 99, 97, 96],
+      [99, 96],
+      3,
+    )).toEqual([100, 98, 97])
+  })
+
+  it('rejects an invalid limit', () => {
+    expect(() => planV2Backfill([100], [], 0)).toThrow(/limit/i)
+  })
+})
diff --git a/server/utils/scores.ts b/server/utils/scores.ts
index ca00e218..ab45294f 100644
--- a/server/utils/scores.ts
+++ b/server/utils/scores.ts
@@ -1,64 +1,282 @@
-import type { Range, Result, ScoreParams } from 'nimiq-validator-trustscore/types'
-import type { NewScore } from './drizzle'
-import { and, desc, eq, gte, lte, or, sql } from 'drizzle-orm'
+import type {
+  Range,
+  Result,
+  ResultSync,
+  ScoreParams,
+  ScoreV2Epoch,
+} from 'nimiq-validator-trustscore/types'
+import type { NewScore, ScoreVersion, Score as StoredScore } from './drizzle'
+import { and, desc, eq, gte, isNull, lt, lte, sql } from 'drizzle-orm'
+import { alias } from 'drizzle-orm/sqlite-core'
+import {
+  classifyValidatorEpoch,
+  ValidatorEpochStatus,
+} from 'nimiq-validator-trustscore/epoch-status'
 import { getRange } from 'nimiq-validator-trustscore/range'
-import { computeScore } from 'nimiq-validator-trustscore/score'
+import { computeScore, getDominance } from 'nimiq-validator-trustscore/score'
+import {
+  computeScoreV2,
+  getRecentAvailabilityV2,
+} from 'nimiq-validator-trustscore/score-v2'
 import { activity } from '../db/schema'
+import {
+  calculateActivityCoverage,
+  getRecentEpochRange,
+} from './activity-epochs'
 import { isScoreLagMissing } from './score-freshness'
 import { getStoredValidatorsId } from './validators'
 
+const SCORE_UPSERT_CHUNK_SIZE = 5
+const SCORE_V2_BACKFILL_LIMIT = 2
+
+interface ScoreCounts {
+  v1: number
+  v2: number
+}
+
 interface CalculateScoreResult {
   range: Range
   scores: ({ params: ScoreParams } & Score)[]
+  dataStatus: 'complete' | 'stale'
+  missingEpochs: number[]
+  scoreCounts: ScoreCounts
+  recentCoverage: number
+  longTermCoverage: number
+  backfilledEpochs: number[]
 }
 
-async function calculateScore(range: Range, validatorId: number): Result<CalculateScoreResult['scores'][number]> {
-  const dominanceRatio = await useDrizzle()
-    .select({
-      dominanceViaSlots: activity.dominanceRatioViaSlots,
-      dominanceViaBalance: activity.dominanceRatioViaBalance,
-    })
-    .from(activity)
-    .where(and(
-      eq(activity.validatorId, validatorId),
-      gte(activity.epochNumber, range.fromEpoch),
-      lte(activity.epochNumber, range.toEpoch),
-      or(
-        gte(activity.dominanceRatioViaBalance, 0),
-        gte(activity.dominanceRatioViaSlots, 0),
-      ),
-    ))
-    .orderBy(desc(activity.epochNumber))
-    .limit(1)
-    .execute()
-    .then((results) => {
-      if (results.length === 0)
-        return 0 // No dominance ratio found for this validator
-      const { dominanceViaBalance, dominanceViaSlots } = results.at(0)!
-      return dominanceViaBalance >= 0 ? dominanceViaBalance : dominanceViaSlots
+export interface ScoreSyncOptions {
+  onProgress?: (message: string) => void
+}
+
+interface ScoreActivityRow {
+  validatorId: number
+  epoch: number
+  likelihood: number
+  missed: number
+  rewarded: number
+  dominanceViaSlots: number
+  dominanceViaBalance: number
+  balance: number
+  stakers: number
+}
+
+export type ScoreV2Mode = 'off' | 'shadow' | 'active'
+
+interface ScoreRollout {
+  writeV1: true
+  writeV2: boolean
+  activeVersion: 1 | 2
+}
+
+type ScoreV2ActivityRow = ScoreActivityRow
+
+interface BuildScoreV2EpochsParams {
+  validatorId: number
+  range: Pick<Range, 'fromEpoch' | 'toEpoch'>
+  activities: readonly ScoreV2ActivityRow[]
+}
+
+interface LongTermPair {
+  longTermAvailability: number
+  reliability: number
+}
+
+interface PriorLongTermState extends LongTermPair {
+  longTermAsOfEpoch: number
+}
+
+interface ResolveLongTermStateParams {
+  coverage: number
+  targetEpoch: number
+  computed?: LongTermPair
+  prior?: PriorLongTermState
+}
+
+interface ResolvedLongTermState extends PriorLongTermState {
+  longTermCoverage: number
+}
+
+export function parseScoreV2Mode(value: string | undefined): ScoreV2Mode {
+  if (value === undefined)
+    return 'off'
+  if (value === 'off' || value === 'shadow' || value === 'active')
+    return value
+  throw new Error(`Invalid score v2 mode: ${value}`)
+}
+
+export function getScoreRollout(mode: ScoreV2Mode): ScoreRollout {
+  switch (mode) {
+    case 'off':
+      return { writeV1: true, writeV2: false, activeVersion: 1 }
+    case 'shadow':
+      return { writeV1: true, writeV2: true, activeVersion: 1 }
+    case 'active':
+      return { writeV1: true, writeV2: true, activeVersion: 2 }
+    default:
+      throw new Error(`Invalid score v2 mode: ${String(mode)}`)
+  }
+}
+
+export function buildScoreV2Epochs(
+  params: BuildScoreV2EpochsParams,
+): ResultSync<ScoreV2Epoch[]> {
+  const { validatorId, range, activities } = params
+  if (!Number.isInteger(validatorId) || validatorId < 1)
+    return [false, `Invalid validator id: ${validatorId}`, undefined]
+  if (
+    !Number.isInteger(range.fromEpoch)
+    || !Number.isInteger(range.toEpoch)
+    || range.fromEpoch < 0
+    || range.toEpoch < range.fromEpoch
+  ) {
+    return [false, `Invalid score v2 range: ${JSON.stringify(range)}`, undefined]
+  }
+
+  const activityByEpoch = new Map<number, ScoreV2ActivityRow>()
+  for (const row of activities) {
+    if (row.validatorId !== validatorId)
+      continue
+    if (!Number.isInteger(row.epoch) || row.epoch < range.fromEpoch || row.epoch > range.toEpoch)
+      return [false, `Validator activity epoch ${row.epoch} is outside the finalized range`, undefined]
+    if (activityByEpoch.has(row.epoch))
+      return [false, `Duplicate validator activity for epoch ${row.epoch}`, undefined]
+    activityByEpoch.set(row.epoch, row)
+  }
+
+  const epochs: ScoreV2Epoch[] = []
+  for (let epochNumber = range.toEpoch; epochNumber >= range.fromEpoch; epochNumber--) {
+    const row = activityByEpoch.get(epochNumber)
+    if (!row) {
+      epochs.push({
+        epochNumber,
+        status: ValidatorEpochStatus.NotElectedRandomness,
+        rewarded: -1,
+        missed: -1,
+      })
+      continue
+    }
+
+    const { status } = classifyValidatorEpoch({
+      likelihood: row.likelihood,
+      dominanceRatioViaSlots: row.dominanceViaSlots,
+      balance: row.balance,
+      stakers: row.stakers,
+      rewarded: row.rewarded,
+      missed: row.missed,
     })
+    if (status === ValidatorEpochStatus.UnknownPlaceholder) {
+      return [
+        false,
+        `Activity integrity error: placeholder in finalized epoch ${epochNumber}`,
+        undefined,
+      ]
+    }
 
-  // Get all activity data for the validator in the given range in a single query
-  const activities = await useDrizzle()
-    .select({
-      epoch: activity.epochNumber,
-      missed: activity.missed,
-      rewarded: activity.rewarded,
+    epochs.push({
+      epochNumber,
+      status,
+      rewarded: row.rewarded,
+      missed: row.missed,
     })
-    .from(activity)
-    .where(and(
-      eq(activity.validatorId, validatorId),
-      gte(activity.epochNumber, range.fromEpoch),
-      lte(activity.epochNumber, range.toEpoch),
-    ))
-    .execute()
+  }
+
+  return [true, undefined, epochs]
+}
+
+export function resolveLongTermState(
+  params: ResolveLongTermStateParams,
+): ResolvedLongTermState | null {
+  const { coverage, targetEpoch, computed, prior } = params
+  if (!isUnitValue(coverage))
+    throw new Error(`Invalid long-term coverage: ${coverage}`)
+  if (!Number.isInteger(targetEpoch) || targetEpoch < 0)
+    throw new Error(`Invalid target score epoch: ${targetEpoch}`)
+
+  if (coverage === 1) {
+    if (!computed)
+      return null
+    validateLongTermPair(computed)
+    return {
+      ...computed,
+      longTermCoverage: coverage,
+      longTermAsOfEpoch: targetEpoch,
+    }
+  }
+
+  if (!prior)
+    return null
+  validateLongTermPair(prior)
+  if (!Number.isInteger(prior.longTermAsOfEpoch) || prior.longTermAsOfEpoch < 0)
+    throw new Error(`Invalid long-term as-of epoch: ${prior.longTermAsOfEpoch}`)
+  if (prior.longTermAsOfEpoch > targetEpoch)
+    return null
+
+  return {
+    ...prior,
+    longTermCoverage: coverage,
+  }
+}
+
+export function planV2Backfill(
+  v1Epochs: readonly number[],
+  v2Epochs: readonly number[],
+  limit: number,
+): number[] {
+  if (!Number.isInteger(limit) || limit <= 0)
+    throw new Error(`Invalid v2 backfill limit: ${limit}`)
+
+  for (const epoch of [...v1Epochs, ...v2Epochs]) {
+    if (!Number.isInteger(epoch) || epoch < 0)
+      throw new Error(`Invalid score epoch: ${epoch}`)
+  }
+
+  const existingV2 = new Set(v2Epochs)
+  return [...new Set(v1Epochs)]
+    .filter(epoch => !existingV2.has(epoch))
+    .sort((a, b) => b - a)
+    .slice(0, limit)
+}
+
+function isUnitValue(value: number): boolean {
+  return Number.isFinite(value) && value >= 0 && value <= 1
+}
+
+function validateLongTermPair(pair: LongTermPair): void {
+  if (!isUnitValue(pair.longTermAvailability))
+    throw new Error(`Invalid long-term availability: ${pair.longTermAvailability}`)
+  if (!isUnitValue(pair.reliability))
+    throw new Error(`Invalid retained reliability: ${pair.reliability}`)
+}
+
+function getLatestDominanceRatio(activities: readonly ScoreActivityRow[]): number {
+  let dominanceRatio = 0
+  let latestDominanceEpoch = Number.NEGATIVE_INFINITY
+
+  for (const row of activities) {
+    if (row.epoch <= latestDominanceEpoch || (row.dominanceViaBalance < 0 && row.dominanceViaSlots < 0))
+      continue
+    dominanceRatio = row.dominanceViaBalance >= 0
+      ? row.dominanceViaBalance
+      : row.dominanceViaSlots
+    latestDominanceEpoch = row.epoch
+  }
+
+  return dominanceRatio
+}
+
+function calculateScore(
+  range: Range,
+  validatorId: number,
+  activities: readonly ScoreActivityRow[],
+): ResultSync<CalculateScoreResult['scores'][number]> {
+  const epochData = new Map<number, { rewarded: number, missed: number }>()
+
+  for (const row of activities)
+    epochData.set(row.epoch, { missed: row.missed, rewarded: row.rewarded })
 
-  // Process the data in memory
   const inherentsPerEpoch = new Map<number, { rewarded: number, missed: number }>()
-  const epochData = new Map(activities.map(a => [a.epoch, { missed: a.missed, rewarded: a.rewarded }]))
   const activeEpochStates: (0 | 1)[] = []
-
-  // Process epochs in order and handle missing data
   for (let epoch = range.fromEpoch; epoch <= range.toEpoch; epoch++) {
     const data = epochData.get(epoch) || { missed: -1, rewarded: -1 }
     inherentsPerEpoch.set(epoch, data)
@@ -67,63 +285,515 @@ async function calculateScore(range: Range, validatorId: number): Result<Calcula
 
   const params: ScoreParams = {
     availability: { activeEpochStates },
-    dominance: { dominanceRatio },
+    dominance: { dominanceRatio: getLatestDominanceRatio(activities) },
     reliability: { inherentsPerEpoch },
   }
   const [scoreAreOk, errorScore, scoreValues] = computeScore(params)
   if (!scoreAreOk)
     return [false, errorScore, undefined]
+
   const score: Score = {
     ...scoreValues,
     validatorId,
     epochNumber: range.toEpoch,
+    scoreVersion: 1,
+    recentAvailability: null,
+    longTermAvailability: null,
+    dataStatus: 'complete',
+    longTermCoverage: null,
+    longTermAsOfEpoch: null,
   }
   return [true, undefined, { ...score, params }]
 }
 
-/**
- * Given a range of epochs, it will compute the score for each validator entry found in the activity table.
- */
-export async function upsertScoresSnapshotEpoch(): Result<CalculateScoreResult> {
-  const { nimiqNetwork: network } = useSafeRuntimeConfig().public
-  const [rangeSuccess, errorRange, range] = await getRange({ network })
-  if (!rangeSuccess || !range)
-    return [false, errorRange || 'No range', undefined]
+async function getFinalizedEpochNumbers(
+  range: Pick<Range, 'fromEpoch' | 'toEpoch'>,
+): Promise<number[]> {
+  return useDrizzle()
+    .select({ epochNumber: tables.activityEpochs.epochNumber })
+    .from(tables.activityEpochs)
+    .where(and(
+      eq(tables.activityEpochs.status, 'finalized'),
+      gte(tables.activityEpochs.epochNumber, range.fromEpoch),
+      lte(tables.activityEpochs.epochNumber, range.toEpoch),
+    ))
+    .execute()
+    .then(markers => markers.map(marker => marker.epochNumber))
+}
 
-  const validatorsId = await getStoredValidatorsId()
-  const scorePromises = validatorsId.map(validatorId => calculateScore(range, validatorId))
-  const maybeRes = await Promise.all(scorePromises)
+async function getScoreActivityRows(
+  range: Pick<Range, 'fromEpoch' | 'toEpoch'>,
+): Promise<ScoreActivityRow[]> {
+  return useDrizzle()
+    .select({
+      validatorId: activity.validatorId,
+      epoch: activity.epochNumber,
+      likelihood: activity.likelihood,
+      missed: activity.missed,
+      rewarded: activity.rewarded,
+      dominanceViaSlots: activity.dominanceRatioViaSlots,
+      dominanceViaBalance: activity.dominanceRatioViaBalance,
+      balance: activity.balance,
+      stakers: activity.stakers,
+    })
+    .from(activity)
+    .where(and(
+      gte(activity.epochNumber, range.fromEpoch),
+      lte(activity.epochNumber, range.toEpoch),
+    ))
+    .execute()
+}
 
-  // If we have an error, we stop
-  if (maybeRes.some(s => !s[0]))
-    return [false, maybeRes.filter(s => !s[0]).map(s => s[1]).join(', '), undefined]
+function groupActivityByValidator(
+  activities: readonly ScoreActivityRow[],
+): Map<number, ScoreActivityRow[]> {
+  const activityByValidatorId = new Map<number, ScoreActivityRow[]>()
+  for (const row of activities) {
+    const validatorActivity = activityByValidatorId.get(row.validatorId) || []
+    validatorActivity.push(row)
+    activityByValidatorId.set(row.validatorId, validatorActivity)
+  }
+  return activityByValidatorId
+}
 
-  const scores = maybeRes.map(s => s[2]!)
+function findFinalizedPlaceholder(
+  activities: readonly ScoreActivityRow[],
+  finalizedEpochs: ReadonlySet<number>,
+): string | undefined {
+  for (const row of activities) {
+    if (!finalizedEpochs.has(row.epoch))
+      continue
+    const { status } = classifyValidatorEpoch({
+      likelihood: row.likelihood,
+      dominanceRatioViaSlots: row.dominanceViaSlots,
+      balance: row.balance,
+      stakers: row.stakers,
+      rewarded: row.rewarded,
+      missed: row.missed,
+    })
+    if (status === ValidatorEpochStatus.UnknownPlaceholder)
+      return `Activity integrity error: placeholder in finalized epoch ${row.epoch}`
+  }
+}
 
-  // Write the scores to the database
-  await useDrizzle()
-    .delete(tables.scores)
-    .where(eq(tables.scores.epochNumber, range.toEpoch)) // Delete all scores for that epoch
+async function getPriorLongTermStates(
+  targetEpoch: number,
+): Promise<Map<number, PriorLongTermState>> {
+  const priorRows = await useDrizzle()
+    .select({
+      validatorId: tables.scores.validatorId,
+      epochNumber: tables.scores.epochNumber,
+      longTermAvailability: tables.scores.longTermAvailability,
+      reliability: tables.scores.reliability,
+      longTermAsOfEpoch: tables.scores.longTermAsOfEpoch,
+    })
+    .from(tables.scores)
+    .where(and(
+      eq(tables.scores.scoreVersion, 2),
+      lte(tables.scores.epochNumber, targetEpoch),
+    ))
+    .orderBy(desc(tables.scores.epochNumber))
     .execute()
 
-  // Save the new scores to the database in batches of 5, otherwise cloudflare might complain "too many parameters"
-  for (let i = 0; i < scores.length; i += 5) {
-    const newScores = scores.slice(i, i + 5).map(score => ({ ...score, params: undefined })) as NewScore[]
+  const priorByValidatorId = new Map<number, PriorLongTermState>()
+  for (const row of priorRows) {
+    if (
+      priorByValidatorId.has(row.validatorId)
+      || row.longTermAvailability === null
+      || row.longTermAsOfEpoch === null
+      || row.longTermAsOfEpoch > targetEpoch
+    ) {
+      continue
+    }
+    priorByValidatorId.set(row.validatorId, {
+      longTermAvailability: row.longTermAvailability,
+      reliability: row.reliability,
+      longTermAsOfEpoch: row.longTermAsOfEpoch,
+    })
+  }
+  return priorByValidatorId
+}
+
+interface CalculateV2ScoresParams {
+  targetEpoch: number
+  recentRange: Pick<Range, 'fromEpoch' | 'toEpoch'>
+  longTermRange: Pick<Range, 'fromEpoch' | 'toEpoch'>
+  longTermCoverage: number
+  validatorIds: readonly number[]
+  activities: readonly ScoreActivityRow[]
+}
+
+async function calculateV2Scores(
+  params: CalculateV2ScoresParams,
+): Promise<ResultSync<Score[]>> {
+  const {
+    targetEpoch,
+    recentRange,
+    longTermRange,
+    longTermCoverage,
+    validatorIds,
+    activities,
+  } = params
+  const activityByValidatorId = groupActivityByValidator(activities)
+  const priorByValidatorId = longTermCoverage < 1
+    ? await getPriorLongTermStates(targetEpoch)
+    : new Map<number, PriorLongTermState>()
+  const scores: Score[] = []
+
+  for (const validatorId of validatorIds) {
+    const validatorActivity = activityByValidatorId.get(validatorId) || []
+    const recentActivity = validatorActivity.filter(
+      row => row.epoch >= recentRange.fromEpoch && row.epoch <= recentRange.toEpoch,
+    )
+    const [recentEpochsSuccess, recentEpochsError, recentEpochs] = buildScoreV2Epochs({
+      validatorId,
+      range: recentRange,
+      activities: recentActivity,
+    })
+    if (!recentEpochsSuccess)
+      return [false, recentEpochsError, undefined]
+
+    if (recentEpochs.every(epoch => epoch.status === ValidatorEpochStatus.NotElectedRandomness))
+      continue
+
+    const dominanceRatio = getLatestDominanceRatio(validatorActivity)
+    if (longTermCoverage === 1) {
+      const longTermActivity = validatorActivity.filter(
+        row => row.epoch >= longTermRange.fromEpoch && row.epoch <= longTermRange.toEpoch,
+      )
+      const [longTermEpochsSuccess, longTermEpochsError, longTermEpochs] = buildScoreV2Epochs({
+        validatorId,
+        range: longTermRange,
+        activities: longTermActivity,
+      })
+      if (!longTermEpochsSuccess)
+        return [false, longTermEpochsError, undefined]
+
+      const [scoreSuccess, scoreError, score] = computeScoreV2({
+        dominance: { dominanceRatio },
+        recentEpochs,
+        longTermEpochs,
+      })
+      if (!scoreSuccess)
+        return [false, scoreError, undefined]
+
+      scores.push({
+        ...score,
+        validatorId,
+        epochNumber: targetEpoch,
+        scoreVersion: 2,
+        dataStatus: 'complete',
+        longTermCoverage,
+        longTermAsOfEpoch: targetEpoch,
+      })
+      continue
+    }
+
+    let longTermState: ResolvedLongTermState | null
+    try {
+      longTermState = resolveLongTermState({
+        coverage: longTermCoverage,
+        targetEpoch,
+        prior: priorByValidatorId.get(validatorId),
+      })
+    }
+    catch (error) {
+      return [false, `Invalid retained long-term state: ${String(error)}`, undefined]
+    }
+    if (!longTermState)
+      continue
+
+    const [recentSuccess, recentError, recentAvailability] = getRecentAvailabilityV2(recentEpochs)
+    if (!recentSuccess)
+      return [false, recentError, undefined]
+    const [dominanceSuccess, dominanceError, dominance] = getDominance({ dominanceRatio })
+    if (!dominanceSuccess)
+      return [false, dominanceError, undefined]
+
+    const availability = 0.5 * longTermState.longTermAvailability + 0.5 * recentAvailability
+    const total = dominance * availability * longTermState.reliability
+    if (![dominance, availability, total].every(isUnitValue))
+      return [false, `Invalid retained score v2 output for validator ${validatorId}`, undefined]
+
+    scores.push({
+      validatorId,
+      epochNumber: targetEpoch,
+      scoreVersion: 2,
+      dominance,
+      recentAvailability,
+      longTermAvailability: longTermState.longTermAvailability,
+      availability,
+      reliability: longTermState.reliability,
+      total,
+      dataStatus: 'complete',
+      longTermCoverage: longTermState.longTermCoverage,
+      longTermAsOfEpoch: longTermState.longTermAsOfEpoch,
+    })
+  }
+
+  return [true, undefined, scores]
+}
+
+function createHistoricalRange(range: Range, targetEpoch: number): Range {
+  const fromEpoch = Math.max(1, targetEpoch - range.epochCount + 1)
+  return {
+    ...range,
+    headEpoch: targetEpoch + 1,
+    epochCount: targetEpoch - fromEpoch + 1,
+    fromEpoch,
+    toEpoch: targetEpoch,
+    snapshotEpoch: targetEpoch + 1,
+  }
+}
+
+async function prepareV2Backfill(
+  range: Range,
+  options: ScoreSyncOptions,
+): Promise<ResultSync<{ epochs: number[], scores: Score[] }>> {
+  const v2Scores = alias(tables.scores, 'v2_scores')
+  options.onProgress?.('checking v2 backfill candidates')
+  const candidates = await useDrizzle()
+    .selectDistinct({ epochNumber: tables.scores.epochNumber })
+    .from(tables.scores)
+    .leftJoin(v2Scores, and(
+      eq(v2Scores.validatorId, tables.scores.validatorId),
+      eq(v2Scores.epochNumber, tables.scores.epochNumber),
+      eq(v2Scores.scoreVersion, 2),
+    ))
+    .where(and(
+      eq(tables.scores.scoreVersion, 1),
+      lt(tables.scores.epochNumber, range.toEpoch),
+      isNull(v2Scores.validatorId),
+    ))
+    .orderBy(desc(tables.scores.epochNumber))
+    .limit(SCORE_V2_BACKFILL_LIMIT)
+    .execute()
+  options.onProgress?.(`backfill found ${candidates.length} candidate epoch(s)`)
+  const backfilledEpochs: number[] = []
+  const backfillScores: Score[] = []
+
+  for (const [index, { epochNumber: targetEpoch }] of candidates.entries()) {
+    const progress = `backfill epoch ${targetEpoch} (${index + 1}/${candidates.length})`
+    options.onProgress?.(`${progress}: checking coverage`)
+    const historicalRange = createHistoricalRange(range, targetEpoch)
+    const recentRange = getRecentEpochRange(historicalRange)
+    const finalizedEpochs = await getFinalizedEpochNumbers(historicalRange)
+    const recentCoverage = calculateActivityCoverage(
+      recentRange.fromEpoch,
+      recentRange.toEpoch,
+      finalizedEpochs,
+    )
+    if (recentCoverage.coverage !== 1)
+      continue
+
+    const longTermCoverage = calculateActivityCoverage(
+      historicalRange.fromEpoch,
+      historicalRange.toEpoch,
+      finalizedEpochs,
+    )
+    const missingValidatorRows = await useDrizzle()
+      .select({ validatorId: tables.scores.validatorId })
+      .from(tables.scores)
+      .leftJoin(v2Scores, and(
+        eq(v2Scores.validatorId, tables.scores.validatorId),
+        eq(v2Scores.epochNumber, tables.scores.epochNumber),
+        eq(v2Scores.scoreVersion, 2),
+      ))
+      .where(and(
+        eq(tables.scores.scoreVersion, 1),
+        eq(tables.scores.epochNumber, targetEpoch),
+        isNull(v2Scores.validatorId),
+      ))
+      .execute()
+    const validatorIds = [...new Set(missingValidatorRows.map(row => row.validatorId))]
+    if (validatorIds.length === 0)
+      continue
+
+    options.onProgress?.(`${progress}: loading activity`)
+    const activities = await getScoreActivityRows(historicalRange)
+    const finalizedEpochSet = new Set(finalizedEpochs)
+    const finalizedActivities = activities.filter(row => finalizedEpochSet.has(row.epoch))
+    const placeholderError = findFinalizedPlaceholder(finalizedActivities, finalizedEpochSet)
+    if (placeholderError)
+      return [false, placeholderError, undefined]
+    options.onProgress?.(`${progress}: calculating ${validatorIds.length} validator(s)`)
+    const [success, error, scores] = await calculateV2Scores({
+      targetEpoch,
+      recentRange,
+      longTermRange: historicalRange,
+      longTermCoverage: longTermCoverage.coverage,
+      validatorIds,
+      activities: finalizedActivities,
+    })
+    if (!success)
+      return [false, error, undefined]
+    if (scores.length === 0)
+      continue
+
+    options.onProgress?.(`${progress}: prepared ${scores.length} score(s)`)
+    backfilledEpochs.push(targetEpoch)
+    backfillScores.push(...scores)
+  }
+
+  return [true, undefined, {
+    epochs: backfilledEpochs,
+    scores: backfillScores,
+  }]
+}
+
+async function upsertScoreRows(
+  scores: readonly (Score | CalculateScoreResult['scores'][number])[],
+  label: string,
+  options: ScoreSyncOptions,
+): Promise<void> {
+  options.onProgress?.(`writing ${label}: ${scores.length} score(s)`)
+  for (let i = 0; i < scores.length; i += SCORE_UPSERT_CHUNK_SIZE) {
+    const newScores = scores
+      .slice(i, i + SCORE_UPSERT_CHUNK_SIZE)
+      .map(score => ({ ...score, params: undefined })) as NewScore[]
     await useDrizzle()
       .insert(tables.scores)
       .values(newScores)
+      .onConflictDoUpdate({
+        target: [
+          tables.scores.validatorId,
+          tables.scores.epochNumber,
+          tables.scores.scoreVersion,
+        ],
+        set: {
+          total: sql`excluded.total`,
+          availability: sql`excluded.availability`,
+          recentAvailability: sql`excluded.recent_availability`,
+          longTermAvailability: sql`excluded.long_term_availability`,
+          dominance: sql`excluded.dominance`,
+          reliability: sql`excluded.reliability`,
+          dataStatus: sql`excluded.data_status`,
+          longTermCoverage: sql`excluded.long_term_coverage`,
+          longTermAsOfEpoch: sql`excluded.long_term_as_of_epoch`,
+        },
+      })
       .execute()
+    options.onProgress?.(`stored ${label} rows ${i + newScores.length}/${scores.length}`)
+  }
+}
+
+/**
+ * Computes and persists the current score snapshot, preserving v1 for rollback.
+ */
+export async function upsertScoresSnapshotEpoch(
+  options: ScoreSyncOptions = {},
+): Result<CalculateScoreResult> {
+  const runtimeConfig = useSafeRuntimeConfig() as ReturnType<typeof useSafeRuntimeConfig> & {
+    scoreV2Mode?: string
+  }
+  const publicConfig = runtimeConfig.public as typeof runtimeConfig.public & { scoreV2Mode?: string }
+  const scoreV2Mode = parseScoreV2Mode(runtimeConfig.scoreV2Mode ?? publicConfig.scoreV2Mode)
+  const rollout = getScoreRollout(scoreV2Mode)
+  const { nimiqNetwork: network } = publicConfig
+  const [rangeSuccess, errorRange, range] = await getRange({ network })
+  if (!rangeSuccess || !range)
+    return [false, errorRange || 'No range', undefined]
+  options.onProgress?.(`range ${range.fromEpoch}-${range.toEpoch}; v2 mode ${scoreV2Mode}`)
+
+  const recentRange = getRecentEpochRange(range)
+  options.onProgress?.('loading finalized activity markers')
+  const finalizedEpochs = await getFinalizedEpochNumbers(range)
+  const recentCoverage = calculateActivityCoverage(
+    recentRange.fromEpoch,
+    recentRange.toEpoch,
+    finalizedEpochs,
+  )
+  const longTermCoverage = calculateActivityCoverage(
+    range.fromEpoch,
+    range.toEpoch,
+    finalizedEpochs,
+  )
+  options.onProgress?.(
+    `coverage recent ${(recentCoverage.coverage * 100).toFixed(1)}%; long-term ${(longTermCoverage.coverage * 100).toFixed(1)}%`,
+  )
+  if (recentCoverage.coverage !== 1) {
+    return [true, undefined, {
+      range,
+      scores: [],
+      dataStatus: 'stale',
+      missingEpochs: recentCoverage.missingEpochs,
+      scoreCounts: { v1: 0, v2: 0 },
+      recentCoverage: recentCoverage.coverage,
+      longTermCoverage: longTermCoverage.coverage,
+      backfilledEpochs: [],
+    }]
+  }
+
+  options.onProgress?.('loading validators')
+  const validatorsId = await getStoredValidatorsId()
+  options.onProgress?.(`loaded ${validatorsId.length} validator(s); loading activity`)
+  const activityRows = await getScoreActivityRows(range)
+  options.onProgress?.(`loaded ${validatorsId.length} validator(s), ${activityRows.length} activity row(s)`)
+  const finalizedEpochSet = new Set(finalizedEpochs)
+  const finalizedActivityRows = activityRows.filter(row => finalizedEpochSet.has(row.epoch))
+  const placeholderError = findFinalizedPlaceholder(finalizedActivityRows, finalizedEpochSet)
+  if (placeholderError)
+    return [false, placeholderError, undefined]
+
+  const activityByValidatorId = groupActivityByValidator(activityRows)
+  options.onProgress?.(`calculating current v1 for ${validatorsId.length} validator(s) at epoch ${range.toEpoch}`)
+  const maybeV1Scores = validatorsId.map(validatorId => calculateScore(
+    range,
+    validatorId,
+    activityByValidatorId.get(validatorId) || [],
+  ))
+  const failedV1Scores = maybeV1Scores.filter(score => !score[0])
+  if (failedV1Scores.length > 0)
+    return [false, failedV1Scores.map(score => score[1]).join(', '), undefined]
+  const v1Scores = maybeV1Scores.map(score => score[2]!)
+  await upsertScoreRows(v1Scores, 'current v1', options)
+
+  let v2Scores: Score[] = []
+  let backfilledEpochs: number[] = []
+  if (rollout.writeV2) {
+    options.onProgress?.(`calculating current v2 for ${validatorsId.length} validator(s) at epoch ${range.toEpoch}`)
+    const [v2Success, v2Error, calculatedV2Scores] = await calculateV2Scores({
+      targetEpoch: range.toEpoch,
+      recentRange,
+      longTermRange: range,
+      longTermCoverage: longTermCoverage.coverage,
+      validatorIds: validatorsId,
+      activities: finalizedActivityRows,
+    })
+    if (!v2Success)
+      return [false, v2Error, undefined]
+    v2Scores = calculatedV2Scores
+    await upsertScoreRows(v2Scores, 'current v2', options)
+
+    const [backfillSuccess, backfillError, backfill] = await prepareV2Backfill(range, options)
+    if (!backfillSuccess)
+      return [false, backfillError, undefined]
+    backfilledEpochs = backfill.epochs
+    await upsertScoreRows(backfill.scores, 'v2 backfill', options)
   }
 
-  return [true, undefined, { scores, range }]
+  return [true, undefined, {
+    scores: v1Scores,
+    range,
+    dataStatus: 'complete',
+    missingEpochs: [],
+    scoreCounts: {
+      v1: v1Scores.length,
+      v2: v2Scores.length,
+    },
+    recentCoverage: recentCoverage.coverage,
+    longTermCoverage: longTermCoverage.coverage,
+    backfilledEpochs,
+  }]
 }
 
-export async function getLatestScoreEpoch(): Promise<number | null> {
+export async function getLatestScoreEpoch(scoreVersion: ScoreVersion = 1): Promise<number | null> {
   const latestScoreEpoch = await useDrizzle()
     .select({
       latestScoreEpoch: sql<number>`max(${tables.scores.epochNumber})`,
     })
     .from(tables.scores)
+    .where(eq(tables.scores.scoreVersion, scoreVersion))
     .get()
     .then((res) => {
       const value = res?.latestScoreEpoch
@@ -139,6 +809,21 @@ export async function getLatestScoreEpoch(): Promise<number | null> {
   return latestScoreEpoch
 }
 
+export async function getLatestScoreState(
+  scoreVersion: ScoreVersion = 1,
+): Promise<Pick<StoredScore, 'epochNumber' | 'dataStatus'> | null> {
+  return await useDrizzle()
+    .select({
+      epochNumber: tables.scores.epochNumber,
+      dataStatus: tables.scores.dataStatus,
+    })
+    .from(tables.scores)
+    .where(eq(tables.scores.scoreVersion, scoreVersion))
+    .orderBy(desc(tables.scores.epochNumber))
+    .limit(1)
+    .get() ?? null
+}
+
 export async function isScoreMissingWithLag(
   range: Range,
   allowedLagEpochs = 1,
diff --git a/server/utils/slack.ts b/server/utils/slack.ts
index 405e66a2..26fd5d56 100644
--- a/server/utils/slack.ts
+++ b/server/utils/slack.ts
@@ -120,7 +120,7 @@ export async function sendSlackNotification(options: SlackNotificationOptions):
 
 // Specific notification functions for different scenarios
 export async function sendSyncFailureNotification(
-  syncType: 'missing-epoch' | 'snapshot',
+  syncType: 'missing-epoch' | 'snapshot' | 'scores',
   error: any,
   endpoint?: string,
 ): Promise<void> {
diff --git a/server/utils/types.ts b/server/utils/types.ts
index b69c7a79..de7fc0e0 100644
--- a/server/utils/types.ts
+++ b/server/utils/types.ts
@@ -1,5 +1,5 @@
 import type { ElectedValidator, UnelectedValidator } from 'nimiq-validator-trustscore/types'
-import type { Activity, Score } from './drizzle'
+import type { Activity, ScoreVersion } from './drizzle'
 
 export enum PayoutType {
   Restake = 'restake',
@@ -22,14 +22,31 @@ export interface SnapshotEpochValidators {
   untrackedValidators: (ElectedValidator | UnelectedValidator)[]
 }
 
-type Nullable<T> = {
-  [K in keyof T]: T[K] | null
+export interface StoredSnapshotEpochValidators extends SnapshotEpochValidators {
+  storageOutcome: 'stored' | 'provisioning'
 }
+
 export type FetchedValidator = Omit<Validator, 'logo' | 'contact'> & Pick<Activity, 'balance' | 'stakers'> & {
   logo?: string
-  score: Nullable<Pick<Score, 'total' | 'availability' | 'reliability' | 'dominance' | 'epochNumber'>>
+  score: ScoreApiValue
   dominanceRatio: number | null
 }
 
+export interface ScoreApiValue {
+  scoreVersion: ScoreVersion
+  total: number | null
+  availability: number | null
+  recentAvailability: number | null
+  longTermAvailability: number | null
+  dominance: number | null
+  reliability: number | null
+  epochNumber: number | null
+  scoreEpoch: number | null
+  dataStatus: 'current' | 'stale' | 'no_score'
+  recentCoverage: number
+  longTermCoverage: number | null
+  longTermAsOfEpoch: number | null
+}
+
 export interface SyncStream { kind: 'success' | 'data' | 'log' | 'error', message: string, payload?: any }
 export type SyncStreamReportFn = (json: SyncStream) => void
diff --git a/server/utils/validators.integration.test.ts b/server/utils/validators.integration.test.ts
new file mode 100644
index 00000000..5bcf8dea
--- /dev/null
+++ b/server/utils/validators.integration.test.ts
@@ -0,0 +1,143 @@
+import type { TestDbHarness } from '../test/db-harness'
+import { afterAll, afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import * as schema from '../db/schema'
+import { createTestDbHarness } from '../test/db-harness'
+
+const drizzleState = vi.hoisted(() => ({ db: undefined as unknown }))
+const cacheDefinitions = vi.hoisted(() => new Map<string, {
+  getKey: (_event: unknown, params: Record<string, unknown>) => string
+}>())
+
+vi.mock('./drizzle', () => ({
+  tables: schema,
+  useDrizzle: () => drizzleState.db,
+}))
+
+vi.mock('./logo', () => ({
+  handleValidatorLogo: vi.fn(),
+}))
+
+vi.stubGlobal('defineCachedFunction', (
+  fn: unknown,
+  options: { name: string, getKey: (_event: unknown, params: Record<string, unknown>) => string },
+) => {
+  cacheDefinitions.set(options.name, options)
+  return fn
+})
+
+type ValidatorsModule = typeof import('./validators')
+
+let harness: TestDbHarness
+let validators: ValidatorsModule
+
+beforeEach(async () => {
+  harness = await createTestDbHarness()
+  drizzleState.db = harness.db
+  cacheDefinitions.clear()
+  vi.resetModules()
+  validators = await import('./validators')
+})
+
+afterEach(() => {
+  harness.close()
+  drizzleState.db = undefined
+})
+
+afterAll(() => {
+  vi.unstubAllGlobals()
+})
+
+describe('versioned validator score query', () => {
+  it('filters score version before maximum-epoch grouping', async () => {
+    const [validator] = await harness.db.insert(schema.validators).values({
+      address: 'validator-1',
+      name: 'Validator 1',
+      logo: 'logo',
+      hasDefaultLogo: true,
+      accentColor: '#000000',
+      isListed: true,
+    }).returning().all()
+
+    await harness.db.insert(schema.scores).values([
+      {
+        validatorId: validator!.id,
+        epochNumber: 12,
+        scoreVersion: 1,
+        total: 0.1,
+        availability: 0.1,
+        dominance: 0.1,
+        reliability: 0.1,
+      },
+      {
+        validatorId: validator!.id,
+        epochNumber: 10,
+        scoreVersion: 2,
+        total: 0.9,
+        availability: 0.8,
+        recentAvailability: 0.75,
+        longTermAvailability: 0.85,
+        dominance: 0.7,
+        reliability: 0.95,
+        longTermCoverage: 1,
+        longTermAsOfEpoch: 10,
+      },
+    ]).execute()
+    await harness.db.insert(schema.activity).values({
+      validatorId: validator!.id,
+      epochNumber: 12,
+      likelihood: 1,
+      rewarded: 720,
+      missed: 0,
+      dominanceRatioViaBalance: 0.01,
+      dominanceRatioViaSlots: 0.01,
+      balance: 1_000,
+      stakers: 1,
+    }).execute()
+    harness.trace.reset()
+
+    const [success, error, result] = await validators.fetchValidators({} as never, {
+      'only-known': true,
+      'with-identicons': false,
+      'force': false,
+      'epoch-number': 12,
+      'epochNumber': 12,
+      'scoreVersion': 2,
+    })
+
+    expect(success).toBe(true)
+    expect(error).toBeUndefined()
+    expect(result).toHaveLength(1)
+    expect(result![0]!.score).toMatchObject({
+      scoreVersion: 2,
+      total: 0.9,
+      epochNumber: 10,
+      scoreEpoch: 10,
+      dataStatus: 'stale',
+    })
+
+    const scoreMaximumQuery = harness.trace.executed.find(statement =>
+      /max\(.+scores.+epoch_number/i.test(statement),
+    )
+    expect(scoreMaximumQuery).toMatch(/where.+score_version.+group by/is)
+  })
+})
+
+describe('versioned validator cache keys', () => {
+  it('separates list and detail cache entries by selected score version', () => {
+    const listCache = cacheDefinitions.get('validators')!
+    const detailCache = cacheDefinitions.get('validator')!
+    const baseList = {
+      'only-known': true,
+      'with-identicons': false,
+      'payout-type': undefined,
+      'epochNumber': 20,
+    }
+    const baseDetail = {
+      address: 'validator-1',
+      range: { fromEpoch: 10, toEpoch: 20 },
+    }
+
+    expect(listCache.getKey({}, { ...baseList, scoreVersion: 1 })).not.toBe(listCache.getKey({}, { ...baseList, scoreVersion: 2 }))
+    expect(detailCache.getKey({}, { ...baseDetail, scoreVersion: 1 })).not.toBe(detailCache.getKey({}, { ...baseDetail, scoreVersion: 2 }))
+  })
+})
diff --git a/server/utils/validators.ts b/server/utils/validators.ts
index 4e3646e2..ab784967 100644
--- a/server/utils/validators.ts
+++ b/server/utils/validators.ts
@@ -1,9 +1,9 @@
 import type { SQLWrapper } from 'drizzle-orm'
 import type { H3Event } from 'h3'
 import type { ElectedValidator, Range, Result, UnelectedValidator } from 'nimiq-validator-trustscore/types'
-import type { Score, Validator } from './drizzle'
+import type { ScoreVersion, Validator } from './drizzle'
 import type { MainQuerySchema, ValidatorJSON } from './schemas'
-import type { FetchedValidator, SnapshotEpochValidators } from './types'
+import type { FetchedValidator, ScoreApiValue, SnapshotEpochValidators } from './types'
 import type { ActivityWithStatus } from './validator-activity-status'
 import { consola } from 'consola'
 import { and, asc, desc, eq, gte, inArray, lte, or, sql } from 'drizzle-orm'
@@ -12,6 +12,7 @@ import { resolveLiveActivityMetadata } from './activity-metadata'
 import { tables, useDrizzle } from './drizzle'
 import { handleValidatorLogo } from './logo'
 import { defaultValidatorJSON } from './schemas'
+import { selectScoreHistory, toScoreApiValue } from './score-api'
 import { withValidatorEpochStatus } from './validator-activity-status'
 import { getUnlistedActiveValidatorAddresses, isKnownValidatorProfile } from './validator-listing'
 
@@ -86,8 +87,11 @@ export async function storeValidator(address: string, rest: ValidatorJSON = defa
   const { upsert = false, isListed = false } = options
 
   // If the validator is cached and upsert is not true, return it
-  if (!upsert && validators.has(address)) {
-    return validators.get(address)
+  if (!upsert) {
+    const cachedValidatorId = validators.get(address)
+    if (cachedValidatorId !== undefined)
+      return cachedValidatorId
+    validators.delete(address)
   }
 
   // Check if the validator already exists in the database
@@ -135,7 +139,15 @@ export async function storeValidator(address: string, rest: ValidatorJSON = defa
     consola.error(`There was an error while writing ${address} into the database`, error)
   }
 
-  validators.set(address, validatorId!)
+  if (validatorId !== undefined)
+    validators.set(address, validatorId)
+  return validatorId
+}
+
+export async function storeValidatorStrict(address: string, rest: ValidatorJSON = defaultValidatorJSON): Promise<number> {
+  const validatorId = await storeValidator(address, rest, { throwOnError: true })
+  if (validatorId === undefined)
+    throw new Error(`Failed to resolve validator ID for ${address}`)
   return validatorId
 }
 
@@ -149,10 +161,21 @@ export async function markValidatorsAsUnlisted(addresses: string[]) {
   }))
 }
 
-export type FetchValidatorsOptions = MainQuerySchema & { epochNumber: number }
+export type FetchValidatorsOptions = MainQuerySchema & {
+  epochNumber: number
+  scoreVersion: ScoreVersion
+  recentCoverage?: number
+}
 
 export async function fetchValidators(_event: H3Event, params: FetchValidatorsOptions): Result<FetchedValidator[]> {
-  const { 'payout-type': payoutType, 'only-known': onlyKnown = true, 'with-identicons': withIdenticons, epochNumber } = params
+  const {
+    'payout-type': payoutType,
+    'only-known': onlyKnown = true,
+    'with-identicons': withIdenticons,
+    epochNumber,
+    recentCoverage = 0,
+    scoreVersion,
+  } = params
 
   // Add safety check for epochNumber
   if (epochNumber === null || epochNumber === undefined || !Number.isInteger(epochNumber)) {
@@ -179,6 +202,7 @@ export async function fetchValidators(_event: H3Event, params: FetchValidatorsOp
       })
       .from(tables.scores)
       .where(and(
+        eq(tables.scores.scoreVersion, scoreVersion),
         lte(tables.scores.epochNumber, epochNumber),
         inArray(tables.scores.validatorId, validatorIds),
       ))
@@ -188,16 +212,23 @@ export async function fetchValidators(_event: H3Event, params: FetchValidatorsOp
     const scoresRows = await useDrizzle()
       .select({
         validatorId: tables.scores.validatorId,
+        scoreVersion: tables.scores.scoreVersion,
         total: tables.scores.total,
         availability: tables.scores.availability,
+        recentAvailability: tables.scores.recentAvailability,
+        longTermAvailability: tables.scores.longTermAvailability,
         dominance: tables.scores.dominance,
         reliability: tables.scores.reliability,
         epochNumber: tables.scores.epochNumber,
+        dataStatus: tables.scores.dataStatus,
+        longTermCoverage: tables.scores.longTermCoverage,
+        longTermAsOfEpoch: tables.scores.longTermAsOfEpoch,
       })
       .from(tables.scores)
       .innerJoin(maxScoreEpochs, and(
         eq(tables.scores.validatorId, maxScoreEpochs.validatorId),
         eq(tables.scores.epochNumber, maxScoreEpochs.epochNumber),
+        eq(tables.scores.scoreVersion, scoreVersion),
       ))
       .execute()
 
@@ -274,19 +305,16 @@ export async function fetchValidators(_event: H3Event, params: FetchValidatorsOp
         consola.warn(`Validator ${validator.address} has no score for epoch ${epochNumber} or earlier`)
       }
 
-      const scoreData = scoreRow || { availability: -1, dominance: -1, reliability: -1, total: -1, epochNumber: -1 }
       const activityData = activityRow || { dominanceRatioViaBalance: -1, dominanceRatioViaSlots: -1, balance: -1, stakers: 0, epochNumber: -1 }
       const activityMetadata = resolveLiveActivityMetadata(activityData, activityData, latestActivityMetadata)
 
       const { dominanceRatioViaBalance = -1, dominanceRatioViaSlots = -1 } = activityData
       const { balance, stakers } = activityMetadata
-      const score: FetchedValidator['score'] = {
-        availability: scoreData.availability === -1 ? null : scoreData.availability,
-        reliability: scoreData.reliability === -1 ? null : scoreData.reliability,
-        dominance: scoreData.dominance === -1 ? null : scoreData.dominance,
-        total: !Object.values(scoreData).includes(-1) ? scoreData.total : null,
-        epochNumber: scoreData.epochNumber,
-      }
+      const score = toScoreApiValue(scoreRow ?? null, {
+        requestedEpoch: epochNumber,
+        scoreVersion,
+        recentCoverage,
+      })
 
       return {
         ...rest,
@@ -322,14 +350,28 @@ export async function fetchValidators(_event: H3Event, params: FetchValidatorsOp
 export const cachedFetchValidators = defineCachedFunction((_event: H3Event, params: FetchValidatorsOptions) => fetchValidators(_event, params), {
   maxAge: import.meta.dev ? 0.01 : 10 * 60, // 10 minutes
   name: 'validators',
-  getKey: (_event, p) => `validators:${p['only-known']}:${p['with-identicons']}:${p['payout-type']}:${p.epochNumber}`,
+  getKey: (_event, p) => `validators:${p['only-known']}:${p['with-identicons']}:${p['payout-type']}:${p.epochNumber}:${p.scoreVersion}`,
 })
 
-export interface FetchValidatorOptions { address: string, range: Range }
-export type FetchedValidatorDetails = Validator & { activity: ActivityWithStatus[], scores: Score[], score?: Score }
+export interface FetchValidatorOptions {
+  address: string
+  range: Range
+  scoreVersion: ScoreVersion
+  recentCoverage?: number
+}
+export type FetchedValidatorDetails = Validator & {
+  activity: ActivityWithStatus[]
+  scores: ScoreApiValue[]
+  score: ScoreApiValue
+}
 
 export async function fetchValidator(_event: H3Event, params: FetchValidatorOptions): Result<FetchedValidatorDetails> {
-  const { address, range: { fromEpoch, toEpoch } } = params
+  const {
+    address,
+    range: { fromEpoch, toEpoch },
+    recentCoverage = 0,
+    scoreVersion,
+  } = params
 
   try {
     const validator = (await selectValidatorsWithListState([eq(tables.validators.address, address)])).at(0)
@@ -342,22 +384,24 @@ export async function fetchValidator(_event: H3Event, params: FetchValidatorOpti
       .from(tables.scores)
       .where(and(
         eq(tables.scores.validatorId, validator.id),
+        eq(tables.scores.scoreVersion, scoreVersion),
         gte(tables.scores.epochNumber, fromEpoch),
         lte(tables.scores.epochNumber, toEpoch),
       ))
+      .orderBy(asc(tables.scores.epochNumber))
       .execute()
 
-    const score = await useDrizzle()
-      .select()
-      .from(tables.scores)
-      .where(and(
-        eq(tables.scores.validatorId, validator.id),
-        gte(tables.scores.epochNumber, fromEpoch),
-        lte(tables.scores.epochNumber, toEpoch),
-      ))
-      .orderBy(desc(tables.scores.epochNumber))
-      .limit(1)
-      .then(rows => rows.at(0))
+    const selectedScores = selectScoreHistory(scores, scoreVersion)
+    const score = toScoreApiValue(selectedScores.at(-1) ?? null, {
+      requestedEpoch: toEpoch,
+      scoreVersion,
+      recentCoverage,
+    })
+    const scoreHistory = selectedScores.map(historyScore => toScoreApiValue(historyScore, {
+      requestedEpoch: toEpoch,
+      scoreVersion,
+      recentCoverage,
+    }))
 
     const activity = await useDrizzle()
       .select()
@@ -392,7 +436,12 @@ export async function fetchValidator(_event: H3Event, params: FetchValidatorOpti
       ...resolveLiveActivityMetadata(row, row, latestActivityMetadata),
     }))
 
-    return [true, undefined, { ...validator, scores, activity: activityWithLiveMetadata.map(withValidatorEpochStatus), score }]
+    return [true, undefined, {
+      ...validator,
+      scores: scoreHistory,
+      activity: activityWithLiveMetadata.map(withValidatorEpochStatus),
+      score,
+    }]
   }
   catch (error) {
     consola.error(`Error fetching validator ${address}: ${error}`)
@@ -403,7 +452,7 @@ export async function fetchValidator(_event: H3Event, params: FetchValidatorOpti
 export const cachedFetchValidator = defineCachedFunction((_event: H3Event, params: FetchValidatorOptions) => fetchValidator(_event, params), {
   maxAge: import.meta.dev ? 0.01 : 10 * 60, // 10 minutes
   name: 'validator',
-  getKey: (_event, p) => `validator:${p.address}:${p.range.fromEpoch}:${p.range.toEpoch}`,
+  getKey: (_event, p) => `validator:${p.address}:${p.range.fromEpoch}:${p.range.toEpoch}:${p.scoreVersion}`,
 })
 
 /**
diff --git a/vitest.config.ts b/vitest.config.ts
index 73849c0f..239992b5 100644
--- a/vitest.config.ts
+++ b/vitest.config.ts
@@ -3,6 +3,11 @@ import { join } from 'pathe'
 import { defineConfig } from 'vitest/config'
 
 export default defineConfig({
+  resolve: {
+    alias: {
+      '~~': __dirname,
+    },
+  },
   test: {
     env: config({ path: join(__dirname, '.env.local') }).parsed,
   },
diff --git a/wrangler.json b/wrangler.json
index a0ad3845..919d1d68 100644
--- a/wrangler.json
+++ b/wrangler.json
@@ -13,8 +13,8 @@
       "invocation_logs": true
     }
   },
-  "triggers": { "crons": ["0 */12 * * *"] },
-  "vars": { "NUXT_PUBLIC_NIMIQ_NETWORK": "main-albatross" },
+  "triggers": { "crons": ["0 */6 * * *"] },
+  "vars": { "NUXT_PUBLIC_NIMIQ_NETWORK": "main-albatross", "NUXT_SCORE_V2_MODE": "off" },
   "d1_databases": [{ "binding": "DB", "database_id": "cc9f1d25-676b-4cb3-8af6-887e85a08baa", "database_name": "validators-api-mainnet" }],
   "kv_namespaces": [{ "binding": "CACHE", "id": "4be4d10e6d3444eca6e7c02cdbcd275f" }],
   "r2_buckets": [{ "binding": "BLOB", "bucket_name": "validators-api-mainnet" }],
@@ -25,8 +25,8 @@
       "assets": { "directory": "dist/public" },
       "compatibility_flags": ["nodejs_compat"],
       "observability": { "enabled": true, "logs": { "enabled": true, "invocation_logs": true } },
-      "triggers": { "crons": ["0 */12 * * *"] },
-      "vars": { "NUXT_PUBLIC_NIMIQ_NETWORK": "test-albatross" },
+      "triggers": { "crons": ["0 */6 * * *"] },
+      "vars": { "NUXT_PUBLIC_NIMIQ_NETWORK": "test-albatross", "NUXT_SCORE_V2_MODE": "off" },
       "d1_databases": [{ "binding": "DB", "database_id": "de14e353-5028-4e52-a383-a9cc200d960d", "database_name": "validators-api-testnet" }],
       "kv_namespaces": [{ "binding": "CACHE", "id": "90c1598af92a4e72a767e6601090f014" }],
       "r2_buckets": [{ "binding": "BLOB", "bucket_name": "validators-api-testnet" }]

From 19408041ba64fb72214f28334f22f63c4ec33559 Mon Sep 17 00:00:00 2001
From: Alberto Monterroso <14013679+Albermonte@users.noreply.github.com>
Date: Fri, 31 Jul 2026 16:10:45 +0200
Subject: [PATCH 2/4] feat(scores): infer offline v2 epochs

Treat finalized activity gaps as offline when zero-slot probability falls below 0.1%. Keep score v1 behavior unchanged.
---
 README.md                                     |   2 +
 app/components/ScorePies.vue                  |  27 ++--
 app/components/[UI]/Batches.vue               |  14 +--
 .../src/epoch-status.ts                       |   1 +
 .../src/score-v2.test.ts                      |   6 +
 .../src/score-v2.ts                           |   5 +-
 server/utils/non-election-inference.ts        | 112 +++++++++++++++++
 server/utils/scores.integration.test.ts       |  37 ++++++
 server/utils/scores.test.ts                   |  28 +++++
 server/utils/scores.ts                        |  13 +-
 .../utils/validator-activity-status.test.ts   |  29 ++++-
 server/utils/validator-activity-status.ts     |  42 ++++++-
 server/utils/validators.integration.test.ts   | 119 ++++++++++++++++++
 server/utils/validators.ts                    |  23 +++-
 14 files changed, 436 insertions(+), 22 deletions(-)
 create mode 100644 server/utils/non-election-inference.ts

diff --git a/README.md b/README.md
index a3421053..87fad07e 100644
--- a/README.md
+++ b/README.md
@@ -118,6 +118,8 @@ The Validators API provides endpoints to retrieve validator information for inte
 
 Validator list, detail, and status endpoints accept `score-version=1|2`. Without it, `NUXT_SCORE_V2_MODE=off` and `shadow` select v1, while `active` selects v2. Queries filter by the selected version before choosing the latest score, so responses never mix v1 and v2 history.
 
+For score v2, finalized gaps after a validator has been elected estimate the chance of receiving zero of the 512 validator slots from the nearest surrounding stake observations. A complete gap with less than 0.1% estimated random-election probability is marked `inferred_offline`, shown in v2 validator activity, and penalized by v2. Lower-confidence gaps remain `not_elected_randomness` and do not reduce availability. Score v1 behavior remains unchanged.
+
 Every score includes its version and data state:
 
 - `current`: selected-version score covers the latest completed epoch.
diff --git a/app/components/ScorePies.vue b/app/components/ScorePies.vue
index 2c41b46f..c5754287 100644
--- a/app/components/ScorePies.vue
+++ b/app/components/ScorePies.vue
@@ -48,22 +48,31 @@ function formatCoverage(value: number | null) {
       </div>
       <template v-else>
         <div>
-          <h4 nq-label text="0.5em center">
-            recent
+          <h4 nq-label text="0.5em center" whitespace-nowrap>
+            recent availability
+            <span block mt-1 text="0.8em neutral/50" font-normal tracking-normal normal-case>
+              Last 14 days
+            </span>
           </h4>
-          <ScorePie text="neutral/70" mx-auto mt-6 size-2.75em :score="recentAvailability" />
+          <ScorePie text="neutral/70" mx-auto mt-4 size-2.75em :score="recentAvailability" />
         </div>
         <div>
-          <h4 nq-label text="0.5em center">
-            long-term
+          <h4 nq-label text="0.5em center" whitespace-nowrap>
+            long-term availability
+            <span block mt-1 text="0.8em neutral/50" font-normal tracking-normal normal-case>
+              About 9 months
+            </span>
           </h4>
-          <ScorePie text="neutral/70" mx-auto mt-6 size-2.75em :score="longTermAvailability" />
+          <ScorePie text="neutral/70" mx-auto mt-4 size-2.75em :score="longTermAvailability" />
         </div>
         <div>
-          <h4 nq-label text="0.5em center">
-            combined
+          <h4 nq-label text="0.5em center" whitespace-nowrap>
+            combined availability
+            <span block mt-1 text="0.8em neutral/50" font-normal tracking-normal normal-case>
+              50% recent + 50% long-term
+            </span>
           </h4>
-          <ScorePie text="neutral/70" mx-auto mt-6 size-2.75em :score="availability" />
+          <ScorePie text="neutral/70" mx-auto mt-4 size-2.75em :score="availability" />
         </div>
       </template>
       <div>
diff --git a/app/components/[UI]/Batches.vue b/app/components/[UI]/Batches.vue
index 6b3c736d..763a1052 100644
--- a/app/components/[UI]/Batches.vue
+++ b/app/components/[UI]/Batches.vue
@@ -1,10 +1,7 @@
 <script setup lang="ts">
-import type { ValidatorEpochStatusResult } from '~~/packages/nimiq-validator-trustscore/src/epoch-status'
-import type { Activity } from '~~/server/utils/drizzle'
+import type { ActivityWithStatus } from '~~/server/utils/validator-activity-status'
 import { ValidatorEpochStatus } from '~~/packages/nimiq-validator-trustscore/src/epoch-status'
 
-type ActivityWithStatus = Activity & Partial<ValidatorEpochStatusResult>
-
 defineProps<{ activity: ActivityWithStatus[] }>()
 
 const [DefineBatchState, BatchState] = createReusableTemplate<ActivityWithStatus & { title?: string }>()
@@ -13,13 +10,15 @@ function formatMissRate(missRate: number | null | undefined) {
   return missRate === null || missRate === undefined ? 'N/A' : percentageFormatter.format(missRate)
 }
 
-function getTitle({ missed, rewarded, epochNumber, status, missRate }: Partial<ActivityWithStatus>) {
+function getTitle({ missed, rewarded, epochNumber, status, missRate, randomnessProbability }: Partial<ActivityWithStatus>) {
   if (status === ValidatorEpochStatus.NotElectedRandomness)
     return `Epoch ${epochNumber}: not elected by randomness.`
   if (status === ValidatorEpochStatus.UnknownPlaceholder)
     return `Epoch ${epochNumber}: elected, production data not finalized.`
   if (status === ValidatorEpochStatus.InactiveByChoiceOrRemoved)
     return `Epoch ${epochNumber}: inactive or removed.`
+  if (status === ValidatorEpochStatus.InferredOffline)
+    return `Epoch ${epochNumber}: likely offline. Random non-election probability: ${randomnessProbability?.toExponential(2) ?? 'N/A'}.`
   if (status === ValidatorEpochStatus.ElectedFailedOrOffline)
     return `Epoch ${epochNumber}: likely offline or failed.\nMissed: ${missed}.\nRewarded: ${rewarded}.\nMiss rate: ${formatMissRate(missRate)}.`
   if (status === ValidatorEpochStatus.ElectedDegraded)
@@ -30,7 +29,7 @@ function getTitle({ missed, rewarded, epochNumber, status, missRate }: Partial<A
 
 <template>
   <ul grid="~ cols-50 gap-4">
-    <DefineBatchState v-slot="{ missed, rewarded, epochNumber, status, missRate, title }">
+    <DefineBatchState v-slot="{ missed, rewarded, epochNumber, status, missRate, randomnessProbability, title }">
       <div
         :title="title || getTitle({
           missed,
@@ -38,13 +37,14 @@ function getTitle({ missed, rewarded, epochNumber, status, missRate }: Partial<A
           epochNumber,
           status,
           missRate,
+          randomnessProbability,
         })"
         size-16 rounded-full outline="~ 1 offset--1 white/20"
         :class="{
           'bg-green-400': status === ValidatorEpochStatus.ElectedOnline && missed === 0,
           'bg-lime-300': status === ValidatorEpochStatus.ElectedOnline && missed !== 0,
           'bg-yellow-400': status === ValidatorEpochStatus.ElectedDegraded,
-          'bg-red-500': status === ValidatorEpochStatus.ElectedFailedOrOffline,
+          'bg-red-500': status === ValidatorEpochStatus.ElectedFailedOrOffline || status === ValidatorEpochStatus.InferredOffline,
           'bg-zinc-400': status === ValidatorEpochStatus.UnknownPlaceholder,
           'bg-white/20': status === ValidatorEpochStatus.NotElectedRandomness,
           'bg-white/8': status === ValidatorEpochStatus.InactiveByChoiceOrRemoved,
diff --git a/packages/nimiq-validator-trustscore/src/epoch-status.ts b/packages/nimiq-validator-trustscore/src/epoch-status.ts
index 73837e7f..4788484a 100644
--- a/packages/nimiq-validator-trustscore/src/epoch-status.ts
+++ b/packages/nimiq-validator-trustscore/src/epoch-status.ts
@@ -3,6 +3,7 @@ export enum ValidatorEpochStatus {
   ElectedOnline = 'elected_online',
   ElectedDegraded = 'elected_degraded',
   ElectedFailedOrOffline = 'elected_failed_or_offline',
+  InferredOffline = 'inferred_offline',
   UnknownPlaceholder = 'unknown_placeholder',
   InactiveByChoiceOrRemoved = 'inactive_by_choice_or_removed',
 }
diff --git a/packages/nimiq-validator-trustscore/src/score-v2.test.ts b/packages/nimiq-validator-trustscore/src/score-v2.test.ts
index 12dca323..dd1cba46 100644
--- a/packages/nimiq-validator-trustscore/src/score-v2.test.ts
+++ b/packages/nimiq-validator-trustscore/src/score-v2.test.ts
@@ -65,6 +65,12 @@ describe('score v2 recent availability', () => {
       epoch(1, ValidatorEpochStatus.InactiveByChoiceOrRemoved, -1, -1),
     ])).toEqual([true, undefined, 0])
   })
+
+  it('treats inferred offline non-election as zero availability', () => {
+    expect(getRecentAvailabilityV2([
+      epoch(1, 'inferred_offline' as ValidatorEpochStatus, -1, -1),
+    ])).toEqual([true, undefined, 0])
+  })
 })
 
 describe('score v2 long-term availability', () => {
diff --git a/packages/nimiq-validator-trustscore/src/score-v2.ts b/packages/nimiq-validator-trustscore/src/score-v2.ts
index 97fe6ccf..6c50d88f 100644
--- a/packages/nimiq-validator-trustscore/src/score-v2.ts
+++ b/packages/nimiq-validator-trustscore/src/score-v2.ts
@@ -53,6 +53,7 @@ function validateEpochs(epochs: readonly ScoreV2Epoch[]): string | undefined {
           return `Invalid availability counters for epoch ${epoch.epochNumber}`
         break
       case ValidatorEpochStatus.InactiveByChoiceOrRemoved:
+      case ValidatorEpochStatus.InferredOffline:
         if (!(
           (epoch.rewarded === -1 && epoch.missed === -1)
           || (epoch.rewarded === 0 && epoch.missed === 0)
@@ -99,6 +100,7 @@ export function getRecentAvailabilityV2(
         break
       case ValidatorEpochStatus.ElectedFailedOrOffline:
       case ValidatorEpochStatus.InactiveByChoiceOrRemoved:
+      case ValidatorEpochStatus.InferredOffline:
         eligible++
         break
     }
@@ -174,7 +176,8 @@ export function getReliabilityV2(
   if (electedPerformance.length === 0) {
     const availabilityOwnsPenalty = epochs.some(
       epoch => epoch.status === ValidatorEpochStatus.ElectedFailedOrOffline
-        || epoch.status === ValidatorEpochStatus.InactiveByChoiceOrRemoved,
+        || epoch.status === ValidatorEpochStatus.InactiveByChoiceOrRemoved
+        || epoch.status === ValidatorEpochStatus.InferredOffline,
     )
     return availabilityOwnsPenalty
       ? [true, undefined, 1]
diff --git a/server/utils/non-election-inference.ts b/server/utils/non-election-inference.ts
new file mode 100644
index 00000000..ab3e6411
--- /dev/null
+++ b/server/utils/non-election-inference.ts
@@ -0,0 +1,112 @@
+import { SLOTS } from '@nimiq/utils/albatross-policy'
+import { ValidatorEpochStatus } from '../../packages/nimiq-validator-trustscore/src/epoch-status'
+
+export const MAX_RANDOM_NON_ELECTION_PROBABILITY = 0.001
+
+export interface ElectionObservation {
+  epochNumber: number
+  dominanceRatioViaBalance: number
+  dominanceRatioViaSlots: number
+}
+
+export interface InferredNonElection {
+  epochNumber: number
+  inferred: true
+  randomnessProbability: number
+  stakeRatio: number
+  status: ValidatorEpochStatus.InferredOffline | ValidatorEpochStatus.NotElectedRandomness
+}
+
+interface InferMissingNonElectionsOptions {
+  fromEpoch: number
+  toEpoch: number
+  activities: readonly ElectionObservation[]
+  finalizedEpochs?: ReadonlySet<number>
+  maxRandomnessProbability?: number
+}
+
+function getStakeRatio(activity: ElectionObservation): number | undefined {
+  const candidates = [
+    activity.dominanceRatioViaBalance,
+    activity.dominanceRatioViaSlots,
+  ].filter(ratio => Number.isFinite(ratio) && ratio > 0 && ratio <= 1)
+
+  return candidates.at(0)
+}
+
+function classifyGap(
+  epochNumbers: readonly number[],
+  previous: ElectionObservation,
+  next: ElectionObservation | undefined,
+  maxRandomnessProbability: number,
+): InferredNonElection[] {
+  const ratios = [getStakeRatio(previous), next ? getStakeRatio(next) : undefined]
+    .filter((ratio): ratio is number => ratio !== undefined)
+  const stakeRatio = ratios.length > 0 ? Math.min(...ratios) : 0
+  const randomnessProbability = stakeRatio > 0
+    ? Math.exp(epochNumbers.length * SLOTS * Math.log1p(-stakeRatio))
+    : 1
+  const status = randomnessProbability < maxRandomnessProbability
+    ? ValidatorEpochStatus.InferredOffline
+    : ValidatorEpochStatus.NotElectedRandomness
+
+  return epochNumbers.map(epochNumber => ({
+    epochNumber,
+    inferred: true,
+    randomnessProbability,
+    stakeRatio,
+    status,
+  }))
+}
+
+export function inferMissingNonElections(
+  options: InferMissingNonElectionsOptions,
+): Map<number, InferredNonElection> {
+  const {
+    fromEpoch,
+    toEpoch,
+    activities,
+    finalizedEpochs,
+    maxRandomnessProbability = MAX_RANDOM_NON_ELECTION_PROBABILITY,
+  } = options
+  if (!(maxRandomnessProbability > 0 && maxRandomnessProbability < 1))
+    throw new Error(`Invalid non-election probability threshold: ${maxRandomnessProbability}`)
+
+  const activityByEpoch = new Map(
+    activities
+      .filter(activity => activity.epochNumber >= fromEpoch && activity.epochNumber <= toEpoch)
+      .map(activity => [activity.epochNumber, activity]),
+  )
+  const inferred = new Map<number, InferredNonElection>()
+  let previous: ElectionObservation | undefined
+  let gap: number[] = []
+
+  for (let epochNumber = fromEpoch; epochNumber <= toEpoch; epochNumber++) {
+    if (finalizedEpochs && !finalizedEpochs.has(epochNumber)) {
+      previous = undefined
+      gap = []
+      continue
+    }
+
+    const activity = activityByEpoch.get(epochNumber)
+    if (!activity) {
+      if (previous)
+        gap.push(epochNumber)
+      continue
+    }
+
+    if (previous && gap.length > 0) {
+      for (const entry of classifyGap(gap, previous, activity, maxRandomnessProbability))
+        inferred.set(entry.epochNumber, entry)
+    }
+    gap = []
+    previous = activity
+  }
+
+  if (previous && gap.length > 0) {
+    for (const entry of classifyGap(gap, previous, undefined, maxRandomnessProbability))
+      inferred.set(entry.epochNumber, entry)
+  }
+
+  return inferred
+}
diff --git a/server/utils/scores.integration.test.ts b/server/utils/scores.integration.test.ts
index 963645cf..9376b27a 100644
--- a/server/utils/scores.integration.test.ts
+++ b/server/utils/scores.integration.test.ts
@@ -278,6 +278,43 @@ describe('marker-gated v1 score persistence', () => {
 })
 
 describe('score v2 rollout persistence', () => {
+  it('penalizes improbable high-stake non-election only in score v2', async () => {
+    const range = createRange(10, 12)
+    const [validator] = await insertValidators(1, 'offline-inference-validator')
+    runtimeConfigState.scoreV2Mode = 'shadow'
+    mocks.getRange.mockResolvedValue([true, undefined, range])
+    await harness.db.insert(schema.activityEpochs).values([
+      finalizedMarker(10, 1),
+      finalizedMarker(11, 0),
+      finalizedMarker(12, 1),
+    ]).execute()
+    await harness.db.insert(schema.activity).values([
+      activityRow(validator!.id, 10, 720, 0, {
+        dominanceRatioViaBalance: -1,
+        dominanceRatioViaSlots: 0.064,
+      }),
+      activityRow(validator!.id, 12, 720, 0, {
+        dominanceRatioViaBalance: -1,
+        dominanceRatioViaSlots: 0.064,
+      }),
+    ]).execute()
+
+    const result = await scores.upsertScoresSnapshotEpoch()
+    expect(result[0]).toBe(true)
+
+    const stored = await harness.db.select()
+      .from(schema.scores)
+      .where(and(
+        eq(schema.scores.validatorId, validator!.id),
+        eq(schema.scores.epochNumber, 12),
+      ))
+      .orderBy(asc(schema.scores.scoreVersion))
+      .all()
+    expect(stored).toHaveLength(2)
+    expect(stored[0]!.availability).toBe(1)
+    expect(stored[1]!.recentAvailability).toBeCloseTo(2 / 3, 12)
+  })
+
   it('writes coexisting v1 and v2 rows in shadow mode and reruns idempotently', async () => {
     const range = createRange(10, 11)
     const [validator] = await insertValidators(1, 'shadow-score-validator')
diff --git a/server/utils/scores.test.ts b/server/utils/scores.test.ts
index c9fc9be7..f76e0d1d 100644
--- a/server/utils/scores.test.ts
+++ b/server/utils/scores.test.ts
@@ -62,6 +62,34 @@ describe('score v2 rollout mode', () => {
 })
 
 describe('score v2 finalized activity mapping', () => {
+  it('maps an improbable high-stake non-election to inferred offline', () => {
+    const result = buildScoreV2Epochs({
+      validatorId: 7,
+      range: { fromEpoch: 10, toEpoch: 12 },
+      activities: [
+        activity(10, {
+          dominanceViaBalance: -1,
+          dominanceViaSlots: 0.064,
+        }),
+        activity(12, {
+          dominanceViaBalance: -1,
+          dominanceViaSlots: 0.064,
+        }),
+      ],
+    })
+
+    expect(result).toEqual([true, undefined, [
+      expect.objectContaining({ epochNumber: 12, status: 'elected_online' }),
+      {
+        epochNumber: 11,
+        status: 'inferred_offline',
+        rewarded: -1,
+        missed: -1,
+      },
+      expect.objectContaining({ epochNumber: 10, status: 'elected_online' }),
+    ]])
+  })
+
   it('maps an absent validator row in a finalized epoch to random non-election', () => {
     const result = buildScoreV2Epochs({
       validatorId: 7,
diff --git a/server/utils/scores.ts b/server/utils/scores.ts
index ab45294f..6f97c9be 100644
--- a/server/utils/scores.ts
+++ b/server/utils/scores.ts
@@ -23,6 +23,7 @@ import {
   calculateActivityCoverage,
   getRecentEpochRange,
 } from './activity-epochs'
+import { inferMissingNonElections } from './non-election-inference'
 import { isScoreLagMissing } from './score-freshness'
 import { getStoredValidatorsId } from './validators'
 
@@ -145,12 +146,22 @@ export function buildScoreV2Epochs(
   }
 
   const epochs: ScoreV2Epoch[] = []
+  const inferredNonElections = inferMissingNonElections({
+    fromEpoch: range.fromEpoch,
+    toEpoch: range.toEpoch,
+    activities: activities.map(row => ({
+      epochNumber: row.epoch,
+      dominanceRatioViaBalance: row.dominanceViaBalance,
+      dominanceRatioViaSlots: row.dominanceViaSlots,
+    })),
+  })
   for (let epochNumber = range.toEpoch; epochNumber >= range.fromEpoch; epochNumber--) {
     const row = activityByEpoch.get(epochNumber)
     if (!row) {
       epochs.push({
         epochNumber,
-        status: ValidatorEpochStatus.NotElectedRandomness,
+        status: inferredNonElections.get(epochNumber)?.status
+          ?? ValidatorEpochStatus.NotElectedRandomness,
         rewarded: -1,
         missed: -1,
       })
diff --git a/server/utils/validator-activity-status.test.ts b/server/utils/validator-activity-status.test.ts
index cdb7d1b4..3a4fc434 100644
--- a/server/utils/validator-activity-status.test.ts
+++ b/server/utils/validator-activity-status.test.ts
@@ -1,7 +1,7 @@
 import type { Activity } from './drizzle'
 import { describe, expect, it } from 'vitest'
 import { ValidatorEpochStatus } from '../../packages/nimiq-validator-trustscore/src/epoch-status'
-import { withValidatorEpochStatus } from './validator-activity-status'
+import { buildValidatorActivityTimeline, withValidatorEpochStatus } from './validator-activity-status'
 
 const baseActivity: Activity = {
   validatorId: 1,
@@ -35,4 +35,31 @@ describe('validator activity status', () => {
       missRate: 1,
     })
   })
+
+  it('does not infer a missing validator row for an unfinalized epoch', () => {
+    const activities = [
+      {
+        ...baseActivity,
+        epochNumber: 10,
+        likelihood: 33,
+        rewarded: 720,
+        missed: 0,
+        dominanceRatioViaSlots: 0.064,
+      },
+      {
+        ...baseActivity,
+        epochNumber: 12,
+        likelihood: 33,
+        rewarded: 720,
+        missed: 0,
+        dominanceRatioViaSlots: 0.064,
+      },
+    ]
+
+    expect(buildValidatorActivityTimeline(
+      { fromEpoch: 10, toEpoch: 12 },
+      activities,
+      new Set([10, 12]),
+    ).map(activity => activity.epochNumber)).toEqual([10, 12])
+  })
 })
diff --git a/server/utils/validator-activity-status.ts b/server/utils/validator-activity-status.ts
index e163da2b..850c4bd2 100644
--- a/server/utils/validator-activity-status.ts
+++ b/server/utils/validator-activity-status.ts
@@ -1,8 +1,14 @@
 import type { ValidatorEpochStatusResult } from '../../packages/nimiq-validator-trustscore/src/epoch-status'
+import type { Range } from '../../packages/nimiq-validator-trustscore/src/types'
 import type { Activity } from './drizzle'
 import { classifyValidatorEpoch } from '../../packages/nimiq-validator-trustscore/src/epoch-status'
+import { inferMissingNonElections } from './non-election-inference'
 
-export type ActivityWithStatus = Activity & ValidatorEpochStatusResult
+export type ActivityWithStatus = Activity & ValidatorEpochStatusResult & {
+  inferred?: true
+  randomnessProbability?: number
+  stakeRatio?: number
+}
 
 export function withValidatorEpochStatus(activity: Activity): ActivityWithStatus {
   return {
@@ -10,3 +16,37 @@ export function withValidatorEpochStatus(activity: Activity): ActivityWithStatus
     ...classifyValidatorEpoch(activity),
   }
 }
+
+export function buildValidatorActivityTimeline(
+  range: Pick<Range, 'fromEpoch' | 'toEpoch'>,
+  activities: readonly Activity[],
+  finalizedEpochs?: ReadonlySet<number>,
+): ActivityWithStatus[] {
+  const inferred = inferMissingNonElections({
+    fromEpoch: range.fromEpoch,
+    toEpoch: range.toEpoch,
+    activities,
+    finalizedEpochs,
+  })
+  const inferredRows: ActivityWithStatus[] = [...inferred.values()].map(epoch => ({
+    validatorId: activities[0]!.validatorId,
+    epochNumber: epoch.epochNumber,
+    likelihood: -1,
+    rewarded: -1,
+    missed: -1,
+    dominanceRatioViaBalance: -1,
+    dominanceRatioViaSlots: -1,
+    balance: -1,
+    stakers: 0,
+    status: epoch.status,
+    missRate: null,
+    inferred: true,
+    randomnessProbability: epoch.randomnessProbability,
+    stakeRatio: epoch.stakeRatio,
+  }))
+
+  return [
+    ...activities.map(withValidatorEpochStatus),
+    ...inferredRows,
+  ].sort((left, right) => left.epochNumber - right.epochNumber)
+}
diff --git a/server/utils/validators.integration.test.ts b/server/utils/validators.integration.test.ts
index 5bcf8dea..2ecdf6e7 100644
--- a/server/utils/validators.integration.test.ts
+++ b/server/utils/validators.integration.test.ts
@@ -1,3 +1,4 @@
+import type { Range } from 'nimiq-validator-trustscore/types'
 import type { TestDbHarness } from '../test/db-harness'
 import { afterAll, afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import * as schema from '../db/schema'
@@ -141,3 +142,121 @@ describe('versioned validator cache keys', () => {
     expect(detailCache.getKey({}, { ...baseDetail, scoreVersion: 1 })).not.toBe(detailCache.getKey({}, { ...baseDetail, scoreVersion: 2 }))
   })
 })
+
+describe('validator activity history', () => {
+  it('exposes an improbable high-stake non-election only for score v2', async () => {
+    const address = 'offline-validator'
+    const [validator] = await harness.db.insert(schema.validators).values({
+      address,
+      name: 'Offline validator',
+      logo: 'logo',
+      hasDefaultLogo: true,
+      accentColor: '#000000',
+      isListed: true,
+    }).returning().all()
+    await harness.db.insert(schema.activity).values([
+      {
+        validatorId: validator!.id,
+        epochNumber: 10,
+        likelihood: 33,
+        rewarded: 720,
+        missed: 0,
+        dominanceRatioViaBalance: -1,
+        dominanceRatioViaSlots: 0.064,
+        balance: 1_000,
+        stakers: 1,
+      },
+      {
+        validatorId: validator!.id,
+        epochNumber: 12,
+        likelihood: 33,
+        rewarded: 720,
+        missed: 0,
+        dominanceRatioViaBalance: -1,
+        dominanceRatioViaSlots: 0.064,
+        balance: 1_000,
+        stakers: 1,
+      },
+    ]).execute()
+    await harness.db.insert(schema.activityEpochs).values([
+      {
+        epochNumber: 10,
+        status: 'finalized',
+        expectedElectedCount: 1,
+        storedElectedCount: 1,
+        electedSetHash: 'marker-10',
+        attemptCount: 1,
+        startedAt: '2026-07-31T08:00:00.000Z',
+        finalizedAt: '2026-07-31T08:05:00.000Z',
+      },
+      {
+        epochNumber: 11,
+        status: 'finalized',
+        expectedElectedCount: 0,
+        storedElectedCount: 0,
+        electedSetHash: 'marker-11',
+        attemptCount: 1,
+        startedAt: '2026-07-31T08:00:00.000Z',
+        finalizedAt: '2026-07-31T08:05:00.000Z',
+      },
+      {
+        epochNumber: 12,
+        status: 'finalized',
+        expectedElectedCount: 1,
+        storedElectedCount: 1,
+        electedSetHash: 'marker-12',
+        attemptCount: 1,
+        startedAt: '2026-07-31T08:00:00.000Z',
+        finalizedAt: '2026-07-31T08:05:00.000Z',
+      },
+    ]).execute()
+    const range: Range = {
+      head: 13,
+      headEpoch: 13,
+      epochCount: 3,
+      epochDurationMs: 12 * 60 * 60 * 1000,
+      fromEpoch: 10,
+      fromBlockNumber: 0,
+      fromTimestamp: 0,
+      toEpoch: 12,
+      toBlockNumber: 12,
+      toTimestamp: 0,
+      snapshotEpoch: 13,
+      snapshotBlock: 13,
+      snapshotTimestamp: 0,
+    }
+
+    const [success, error, result] = await validators.fetchValidator({} as never, {
+      address,
+      range,
+      scoreVersion: 2,
+      recentCoverage: 1,
+    })
+
+    expect(success).toBe(true)
+    expect(error).toBeUndefined()
+    expect(result!.activity).toEqual([
+      expect.objectContaining({ epochNumber: 10, status: 'elected_online' }),
+      expect.objectContaining({
+        epochNumber: 11,
+        status: 'inferred_offline',
+        inferred: true,
+      }),
+      expect.objectContaining({ epochNumber: 12, status: 'elected_online' }),
+    ])
+
+    const [v1Success, v1Error, v1Result] = await validators.fetchValidator({} as never, {
+      address,
+      range,
+      scoreVersion: 1,
+      recentCoverage: 1,
+    })
+
+    expect(v1Success).toBe(true)
+    expect(v1Error).toBeUndefined()
+    expect(v1Result!.activity).toEqual([
+      expect.objectContaining({ epochNumber: 10, status: 'elected_online' }),
+      expect.objectContaining({ epochNumber: 12, status: 'elected_online' }),
+    ])
+  })
+})
diff --git a/server/utils/validators.ts b/server/utils/validators.ts
index ab784967..bd5237eb 100644
--- a/server/utils/validators.ts
+++ b/server/utils/validators.ts
@@ -13,7 +13,7 @@ import { tables, useDrizzle } from './drizzle'
 import { handleValidatorLogo } from './logo'
 import { defaultValidatorJSON } from './schemas'
 import { selectScoreHistory, toScoreApiValue } from './score-api'
-import { withValidatorEpochStatus } from './validator-activity-status'
+import { buildValidatorActivityTimeline, withValidatorEpochStatus } from './validator-activity-status'
 import { getUnlistedActiveValidatorAddresses, isKnownValidatorProfile } from './validator-listing'
 
 export const getStoredValidatorsId = () => useDrizzle().select({ id: tables.validators.id }).from(tables.validators).execute().then(r => r.map(v => v.id))
@@ -414,6 +414,19 @@ export async function fetchValidator(_event: H3Event, params: FetchValidatorOpti
       .orderBy(asc(tables.activity.epochNumber))
       .execute()
 
+    const finalizedEpochs = scoreVersion === 2
+      ? await useDrizzle()
+          .select({ epochNumber: tables.activityEpochs.epochNumber })
+          .from(tables.activityEpochs)
+          .where(and(
+            eq(tables.activityEpochs.status, 'finalized'),
+            gte(tables.activityEpochs.epochNumber, fromEpoch),
+            lte(tables.activityEpochs.epochNumber, toEpoch),
+          ))
+          .execute()
+          .then(rows => new Set(rows.map(row => row.epochNumber)))
+      : undefined
+
     const latestActivityMetadata = await useDrizzle()
       .select({
         balance: tables.activity.balance,
@@ -439,7 +452,13 @@ export async function fetchValidator(_event: H3Event, params: FetchValidatorOpti
     return [true, undefined, {
       ...validator,
       scores: scoreHistory,
-      activity: activityWithLiveMetadata.map(withValidatorEpochStatus),
+      activity: scoreVersion === 2
+        ? buildValidatorActivityTimeline(
+            { fromEpoch, toEpoch },
+            activityWithLiveMetadata,
+            finalizedEpochs,
+          )
+        : activityWithLiveMetadata.map(withValidatorEpochStatus),
       score,
     }]
   }

From 082b24093b8c20de80e3e7332bdc854736955b98 Mon Sep 17 00:00:00 2001
From: Alberto Monterroso <14013679+Albermonte@users.noreply.github.com>
Date: Fri, 31 Jul 2026 17:02:46 +0200
Subject: [PATCH 3/4] fix(scores): require high stake for offline gaps

---
 README.md                              |  2 +-
 server/utils/non-election-inference.ts |  4 +++-
 server/utils/scores.test.ts            | 23 +++++++++++++++++++++++
 3 files changed, 27 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index 87fad07e..c9f19ebe 100644
--- a/README.md
+++ b/README.md
@@ -118,7 +118,7 @@ The Validators API provides endpoints to retrieve validator information for inte
 
 Validator list, detail, and status endpoints accept `score-version=1|2`. Without it, `NUXT_SCORE_V2_MODE=off` and `shadow` select v1, while `active` selects v2. Queries filter by the selected version before choosing the latest score, so responses never mix v1 and v2 history.
 
-For score v2, finalized gaps after a validator has been elected estimate the chance of receiving zero of the 512 validator slots from the nearest surrounding stake observations. A complete gap with less than 0.1% estimated random-election probability is marked `inferred_offline`, shown in v2 validator activity, and penalized by v2. Lower-confidence gaps remain `not_elected_randomness` and do not reduce availability. Score v1 behavior remains unchanged.
+For score v2, finalized gaps after a validator has been elected estimate the chance of receiving zero of the 512 validator slots from the nearest surrounding stake observations. A complete gap is marked `inferred_offline`, shown in v2 validator activity, and penalized by v2 only when estimated stake is at least 1% and random-election probability is below 0.1%. Lower-stake and lower-confidence gaps remain `not_elected_randomness` and do not reduce availability. Score v1 behavior remains unchanged.
 
 Every score includes its version and data state:
 
diff --git a/server/utils/non-election-inference.ts b/server/utils/non-election-inference.ts
index ab3e6411..8d8a5d13 100644
--- a/server/utils/non-election-inference.ts
+++ b/server/utils/non-election-inference.ts
@@ -2,6 +2,7 @@ import { SLOTS } from '@nimiq/utils/albatross-policy'
 import { ValidatorEpochStatus } from '../../packages/nimiq-validator-trustscore/src/epoch-status'
 
 export const MAX_RANDOM_NON_ELECTION_PROBABILITY = 0.001
+export const MIN_HIGH_STAKE_RATIO = 0.01
 
 export interface ElectionObservation {
   epochNumber: number
@@ -46,7 +47,8 @@ function classifyGap(
   const randomnessProbability = stakeRatio > 0
     ? Math.exp(epochNumbers.length * SLOTS * Math.log1p(-stakeRatio))
     : 1
-  const status = randomnessProbability < maxRandomnessProbability
+  const status = stakeRatio >= MIN_HIGH_STAKE_RATIO
+    && randomnessProbability < maxRandomnessProbability
     ? ValidatorEpochStatus.InferredOffline
     : ValidatorEpochStatus.NotElectedRandomness
 
diff --git a/server/utils/scores.test.ts b/server/utils/scores.test.ts
index f76e0d1d..5d2123ce 100644
--- a/server/utils/scores.test.ts
+++ b/server/utils/scores.test.ts
@@ -90,6 +90,29 @@ describe('score v2 finalized activity mapping', () => {
     ]])
   })
 
+  it('keeps a long gap between one-slot elections as random non-election', () => {
+    const [success, error, epochs] = buildScoreV2Epochs({
+      validatorId: 7,
+      range: { fromEpoch: 10, toEpoch: 142 },
+      activities: [
+        activity(10, {
+          dominanceViaBalance: -1,
+          dominanceViaSlots: 1 / 512,
+        }),
+        activity(142, {
+          dominanceViaBalance: -1,
+          dominanceViaSlots: 1 / 512,
+        }),
+      ],
+    })
+
+    expect(success).toBe(true)
+    expect(error).toBeUndefined()
+    const missingEpochs = epochs!.filter(epoch => epoch.rewarded === -1)
+    expect(missingEpochs).toHaveLength(131)
+    expect(missingEpochs.every(epoch => epoch.status === 'not_elected_randomness')).toBe(true)
+  })
+
   it('maps an absent validator row in a finalized epoch to random non-election', () => {
     const result = buildScoreV2Epochs({
       validatorId: 7,

From 9d44e045fdc70e5f77c4846ae98d85698bde74f5 Mon Sep 17 00:00:00 2001
From: Alberto Monterroso <14013679+Albermonte@users.noreply.github.com>
Date: Fri, 31 Jul 2026 17:23:29 +0200
Subject: [PATCH 4/4] chore(scores): enable mainnet shadow mode

---
 nuxt.config.test.ts | 4 ++--
 wrangler.json       | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/nuxt.config.test.ts b/nuxt.config.test.ts
index 0bdff4f3..4fd824df 100644
--- a/nuxt.config.test.ts
+++ b/nuxt.config.test.ts
@@ -17,9 +17,9 @@ describe('score v2 runtime configuration', () => {
     expect(config.runtimeConfig?.scoreV2Mode).toBe('shadow')
   })
 
-  it('publishes the Nitro-compatible variable in both Wrangler environments', () => {
+  it('publishes the expected rollout mode in both Wrangler environments', () => {
     expect(wranglerConfig.vars).toEqual(expect.objectContaining({
-      NUXT_SCORE_V2_MODE: 'off',
+      NUXT_SCORE_V2_MODE: 'shadow',
     }))
     expect(wranglerConfig.env.testnet.vars).toEqual(expect.objectContaining({
       NUXT_SCORE_V2_MODE: 'off',
diff --git a/wrangler.json b/wrangler.json
index 919d1d68..bc6d3bee 100644
--- a/wrangler.json
+++ b/wrangler.json
@@ -14,7 +14,7 @@
     }
   },
   "triggers": { "crons": ["0 */6 * * *"] },
-  "vars": { "NUXT_PUBLIC_NIMIQ_NETWORK": "main-albatross", "NUXT_SCORE_V2_MODE": "off" },
+  "vars": { "NUXT_PUBLIC_NIMIQ_NETWORK": "main-albatross", "NUXT_SCORE_V2_MODE": "shadow" },
   "d1_databases": [{ "binding": "DB", "database_id": "cc9f1d25-676b-4cb3-8af6-887e85a08baa", "database_name": "validators-api-mainnet" }],
   "kv_namespaces": [{ "binding": "CACHE", "id": "4be4d10e6d3444eca6e7c02cdbcd275f" }],
   "r2_buckets": [{ "binding": "BLOB", "bucket_name": "validators-api-mainnet" }],