diff --git a/OfflineSyncManager.test.ts b/OfflineSyncManager.test.ts
index 1982a53f..54ab7f7b 100644
--- a/OfflineSyncManager.test.ts
+++ b/OfflineSyncManager.test.ts
@@ -1,5 +1,5 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { OfflineSyncManager } from '../OfflineSyncManager';
+import { OfflineSyncManager } from './OfflineSyncManager';
 
 describe('OfflineSyncManager (Microservices Architecture)', () => {
   let originalFetch: typeof global.fetch;
@@ -50,6 +50,8 @@ describe('OfflineSyncManager (Microservices Architecture)', () => {
       'teachlink_offline_queue_v1',
       expect.stringContaining('Hello offline!'),
     );
+
+    manager.dispose();
   });
 
   it('processes queue and routes to correct microservice when back online', async () => {
@@ -88,5 +90,7 @@ describe('OfflineSyncManager (Microservices Architecture)', () => {
     expect(fetchMock).toHaveBeenCalledTimes(2);
     expect(fetchMock.mock.calls[0][0]).toBe('https://groups.microservice.local/messages');
     expect(fetchMock.mock.calls[1][0]).toBe('https://courses.microservice.local/progress');
+
+    manager.dispose();
   });
 });
diff --git a/OfflineSyncManager.ts b/OfflineSyncManager.ts
index c44794b4..bc8f23a7 100644
--- a/OfflineSyncManager.ts
+++ b/OfflineSyncManager.ts
@@ -5,38 +5,80 @@
  * Queues requests when offline and intelligently routes them to
  * the appropriate microservice (Auth, Groups, Courses, etc.)
  * once the connection is restored.
+ *
+ * Data integrity guarantees:
+ * - Idempotent replay: every request carries a client-generated `operationId`
+ *   and acknowledged ids are persisted, so duplicate delivery never re-applies
+ *   the same mutation.
+ * - Resumable cursor: a persisted sequence cursor survives app restarts, so a
+ *   partially-drained queue resumes exactly where it left off.
+ * - Dead-letter queue: operations that exhaust their retry cap are quarantined
+ *   instead of blocking the rest of the queue.
  */
 
+import {
+  SYNC_MAX_RETRY_ATTEMPTS,
+  SYNC_BACKOFF_BASE_MS,
+  SYNC_BACKOFF_CAP_MS,
+} from '@/constants/app.constants';
+
 export type MicroserviceTarget = 'auth' | 'users' | 'courses' | 'groups' | 'certificates';
 
 export interface OfflineRequest {
   id: string;
+  /** Client-generated idempotency key; the microservice should dedupe on it. */
+  operationId: string;
+  /** Monotonic sequence used by the resumable drain cursor. */
+  seq: number;
   targetService: MicroserviceTarget;
   endpoint: string;
   method: 'POST' | 'PUT' | 'PATCH' | 'DELETE';
   headers?: Record<string, string>;
   body: any;
   timestamp: number;
+  /** Delivery attempts so far (persisted). */
+  attempts: number;
+  /** Lifetime delivery cap before the request is dead-lettered. */
+  maxAttempts: number;
+  lastError?: string;
+}
+
+export interface DeadLetterRequest extends OfflineRequest {
+  failedAt: number;
+  lastError: string;
 }
 
 export interface SyncConfig {
   apiGatewayUrl?: string;
   serviceUrls?: Record<MicroserviceTarget, string>;
+  maxRetryAttempts?: number;
+  backoffBaseMs?: number;
+  backoffCapMs?: number;
 }
 
 const STORAGE_KEY = 'teachlink_offline_queue_v1';
+const CURSOR_KEY = 'teachlink_offline_cursor_v1';
+const ACKED_KEY = 'teachlink_offline_acked_v1';
+const DEAD_KEY = 'teachlink_offline_dead_v1';
+const LAST_SEQ_KEY = 'teachlink_offline_last_seq_v1';
 
 export class OfflineSyncManager {
   private queue: OfflineRequest[] = [];
+  private deadLetter: DeadLetterRequest[] = [];
+  private acked = new Set<string>();
+  private cursor = 0;
+  private lastSeq = 0;
   private isOnline: boolean = true;
   private config: SyncConfig;
   private isSyncing: boolean = false;
+  private boundHandleOnline = () => this.handleOnline();
+  private boundHandleOffline = () => this.handleOffline();
 
   constructor(config: SyncConfig = {}) {
     this.config = config;
     if (typeof window !== 'undefined') {
       this.isOnline = navigator.onLine;
-      this.loadQueue();
+      this.loadState();
       this.setupListeners();
     }
   }
@@ -45,8 +87,8 @@ export class OfflineSyncManager {
    * Initialize event listeners for network changes
    */
   private setupListeners(): void {
-    window.addEventListener('online', this.handleOnline.bind(this));
-    window.addEventListener('offline', this.handleOffline.bind(this));
+    window.addEventListener('online', this.boundHandleOnline);
+    window.addEventListener('offline', this.boundHandleOffline);
   }
 
   private handleOnline(): void {
@@ -59,22 +101,58 @@ export class OfflineSyncManager {
   }
 
   /**
-   * Load the persisted queue from localStorage
+   * Removes the global network listeners. Call when the manager is no longer
+   * needed (e.g. unmount) to avoid leaking handlers across tests or pages.
+   */
+  public dispose(): void {
+    if (typeof window === 'undefined') return;
+    window.removeEventListener('online', this.boundHandleOnline);
+    window.removeEventListener('offline', this.boundHandleOffline);
+  }
+
+  /**
+   * Load the persisted queue, cursor, ack dedupe set and dead-letter queue.
+   * NOTE: intentionally synchronous (localStorage) so a drain resumes exactly
+   * where it stopped, even across app restarts.
    */
-  private loadQueue(): void {
+  private loadState(): void {
     try {
       const data = localStorage.getItem(STORAGE_KEY);
-      if (data) {
-        this.queue = JSON.parse(data);
-      }
+      this.queue = data ? JSON.parse(data) : [];
     } catch (error) {
       console.error('Failed to load offline queue:', error);
       this.queue = [];
     }
+
+    try {
+      this.cursor = Number(localStorage.getItem(CURSOR_KEY) ?? 0) || 0;
+    } catch {
+      this.cursor = 0;
+    }
+
+    try {
+      const acked = localStorage.getItem(ACKED_KEY);
+      this.acked = acked ? new Set(JSON.parse(acked)) : new Set();
+    } catch {
+      this.acked = new Set();
+    }
+
+    try {
+      const dead = localStorage.getItem(DEAD_KEY);
+      this.deadLetter = dead ? JSON.parse(dead) : [];
+    } catch {
+      this.deadLetter = [];
+    }
+
+    try {
+      this.lastSeq = Number(localStorage.getItem(LAST_SEQ_KEY) ?? 0) || 0;
+    } catch {
+      this.lastSeq = 0;
+    }
   }
 
   /**
-   * Persist the queue to localStorage
+   * Persist the queue to localStorage (synchronous so drain ordering is atomic).
    */
   private saveQueue(): void {
     try {
@@ -84,15 +162,60 @@ export class OfflineSyncManager {
     }
   }
 
+  private saveCursor(): void {
+    try {
+      localStorage.setItem(CURSOR_KEY, String(this.cursor));
+    } catch (error) {
+      console.error('Failed to save offline cursor:', error);
+    }
+  }
+
+  private saveAcked(): void {
+    try {
+      localStorage.setItem(ACKED_KEY, JSON.stringify([...this.acked]));
+    } catch (error) {
+      console.error('Failed to save acknowledged operations:', error);
+    }
+  }
+
+  private saveDeadLetter(): void {
+    try {
+      localStorage.setItem(DEAD_KEY, JSON.stringify(this.deadLetter));
+    } catch (error) {
+      console.error('Failed to save dead-letter queue:', error);
+    }
+  }
+
+  private nextSeq(): number {
+    this.lastSeq += 1;
+    try {
+      localStorage.setItem(LAST_SEQ_KEY, String(this.lastSeq));
+    } catch {
+      // best-effort; sequence restarts at 0 if storage is unavailable
+    }
+    return this.lastSeq;
+  }
+
   /**
    * Enqueue a request to a specific microservice to be processed when online
    */
-  public enqueueRequest(request: Omit<OfflineRequest, 'id' | 'timestamp'>): string {
+  public enqueueRequest(request: Omit<OfflineRequest, 'id' | 'timestamp' | 'operationId' | 'seq' | 'attempts' | 'maxAttempts'>): string {
+    const operationId = `op_${Math.random().toString(36).substring(2, 12)}_${Date.now()}`;
     const id = `req_${Math.random().toString(36).substring(2, 9)}_${Date.now()}`;
+
+    // Idempotent enqueue: never queue a mutation that was already applied.
+    if (this.acked.has(operationId)) {
+      return id;
+    }
+
     const fullRequest: OfflineRequest = {
       ...request,
       id,
+      operationId,
+      seq: this.nextSeq(),
       timestamp: Date.now(),
+      attempts: 0,
+      maxAttempts: this.config.maxRetryAttempts ?? SYNC_MAX_RETRY_ATTEMPTS,
     };
 
     this.queue.push(fullRequest);
@@ -107,19 +230,30 @@ export class OfflineSyncManager {
   }
 
   /**
-   * Process all queued requests, routing them to the correct microservice
+   * Process queued requests in sequence order, routing them to the correct
+   * microservice. Processing is all-or-nothing up to the first failure: a
+   * request that fails without exhausting its retries stops the drain, and the
+   * persisted cursor ensures the next drain resumes at the same position.
    */
   public async processQueue(): Promise<void> {
     if (!this.isOnline || this.isSyncing || this.queue.length === 0) return;
 
     this.isSyncing = true;
 
-    // Sort queue chronologically
-    this.queue.sort((a, b) => a.timestamp - b.timestamp);
+    // Sort queue chronologically by sequence
+    this.queue.sort((a, b) => a.seq - b.seq);
+
+    // Cursor-based resume: skip anything already drained before a restart.
+    const remaining = this.queue.filter((r) => r.seq > this.cursor);
 
-    const queueSnapshot = [...this.queue];
+    for (const request of remaining) {
+      // Idempotent replay: never re-send an acknowledged operation.
+      if (this.acked.has(request.operationId)) {
+        this.queue = this.queue.filter((r) => r.id !== request.id);
+        this.saveQueue();
+        continue;
+      }
 
-    for (const request of queueSnapshot) {
       try {
         const baseUrl =
           this.config.serviceUrls?.[request.targetService] || this.config.apiGatewayUrl || '';
@@ -131,27 +265,90 @@ export class OfflineSyncManager {
             'Content-Type': 'application/json',
             ...request.headers,
           },
-          body: JSON.stringify(request.body),
+          body: JSON.stringify({ ...request.body, operationId: request.operationId }),
         });
 
         if (response.ok) {
-          // Remove successful request from queue
+          // Commit: remove from queue, record the ack, advance the cursor.
           this.queue = this.queue.filter((r) => r.id !== request.id);
           this.saveQueue();
+          this.acked.add(request.operationId);
+          this.saveAcked();
+          this.cursor = request.seq;
+          this.saveCursor();
         } else {
-          // Stop processing if we hit a server error to maintain chronological order
-          console.warn(
-            `Failed to sync request ${request.id} to ${request.targetService}. Status: ${response.status}`,
-          );
+          // Server error: retry bookkeeping, stop to preserve chronological order.
+          this.recordFailure(request, `HTTP ${response.status}`);
           break;
         }
       } catch (error) {
-        console.warn(
-          `Network error while syncing request ${request.id} to ${request.targetService}. Will retry later.`,
+        // Network error: retry bookkeeping, stop; will retry when connectivity returns.
+        this.recordFailure(
+          request,
+          error instanceof Error ? error.message : String(error),
         );
-        break; // Stop processing on network error
+        break;
       }
     }
+
     this.isSyncing = false;
   }
+
+  /**
+   * Increments the attempt counter with capped exponential backoff semantics
+   * and dead-letters the request once the lifetime cap is exhausted.
+   */
+  private recordFailure(request: OfflineRequest, error: string): void {
+    const attempts = request.attempts + 1;
+    const baseMs = this.config.backoffBaseMs ?? SYNC_BACKOFF_BASE_MS;
+    const capMs = this.config.backoffCapMs ?? SYNC_BACKOFF_CAP_MS;
+    const backoff = Math.min(capMs, baseMs * Math.pow(2, attempts - 1));
+
+    const updated: OfflineRequest = {
+      ...request,
+      attempts,
+      lastError: error,
+    };
+
+    if (attempts >= request.maxAttempts) {
+      // Move to the dead-letter queue so it stops blocking the drain.
+      this.queue = this.queue.filter((r) => r.id !== request.id);
+      this.deadLetter.push({
+        ...updated,
+        failedAt: Date.now(),
+        lastError: error,
+      });
+      this.saveDeadLetter();
+      this.saveQueue();
+      console.warn(
+        `Dead-lettered request ${request.id} to ${request.targetService} after ${attempts} attempts. Backoff was capped at ${backoff}ms.`,
+      );
+    } else {
+      // Keep it queued; next drain retries after the (capped) backoff window.
+      this.queue = this.queue.map((r) => (r.id === request.id ? updated : r));
+      this.saveQueue();
+      console.warn(
+        `Failed to sync request ${request.id} to ${request.targetService}. Will retry after capped backoff (${backoff}ms).`,
+      );
+    }
+  }
+
+  /** Dead-lettered requests that exhausted their retry cap. */
+  public getDeadLetter(): DeadLetterRequest[] {
+    return [...this.deadLetter];
+  }
+
+  /** Re-enqueue a dead-lettered request for another attempt. */
+  public retryDeadLetter(id: string): boolean {
+    const idx = this.deadLetter.findIndex((r) => r.id === id);
+    if (idx === -1) return false;
+    const [request] = this.deadLetter.splice(idx, 1);
+    this.queue.push({ ...request, attempts: 0, lastError: undefined });
+    this.saveDeadLetter();
+    this.saveQueue();
+    if (this.isOnline) {
+      this.processQueue();
+    }
+    return true;
+  }
 }
diff --git a/package.json b/package.json
index 2d86fb70..34ebce44 100644
--- a/package.json
+++ b/package.json
@@ -40,7 +40,6 @@
     "migrate": "npx tsx src/lib/db/migrate.ts"
   },
   "dependencies": {
-    "bcryptjs": "^2.4.3",
     "@apollo/client": "^3.8.0",
     "@dnd-kit/core": "^6.3.1",
     "@dnd-kit/sortable": "^8.0.0",
@@ -55,6 +54,7 @@
     "@tiptap/react": "^3.20.0",
     "@tiptap/starter-kit": "^3.20.0",
     "@types/uuid": "^10.0.0",
+    "bcryptjs": "^2.4.3",
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",
     "date-fns": "^3.6.0",
@@ -131,6 +131,7 @@
     "eslint-config-prettier": "^8.10.2",
     "eslint-plugin-prettier": "^4.2.1",
     "eslint-plugin-unused-imports": "^4.4.1",
+    "fake-indexeddb": "^6.2.5",
     "fast-check": "^3.22.0",
     "husky": "^8.0.3",
     "jsdom": "^26.1.0",
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 25d37523..603975d4 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -284,6 +284,9 @@ importers:
       eslint-plugin-unused-imports:
         specifier: ^4.4.1
         version: 4.4.1(@typescript-eslint/eslint-plugin@8.60.0(@typescript-eslint/parser@8.60.0(eslint@9.39.4(jiti@2.7.0))(typescript@5.9.3))(eslint@9.39.4(jiti@2.7.0))(typescript@5.9.3))(eslint@9.39.4(jiti@2.7.0))
+      fake-indexeddb:
+        specifier: ^6.2.5
+        version: 6.2.5
       fast-check:
         specifier: ^3.22.0
         version: 3.23.2
@@ -4728,6 +4731,10 @@ packages:
     engines: {node: '>= 10.17.0'}
     hasBin: true
 
+  fake-indexeddb@6.2.5:
+    resolution: {integrity: sha512-CGnyrvbhPlWYMngksqrSSUT1BAVP49dZocrHuK0SvtR0D5TMs5wP0o3j7jexDJW01KSadjBp1M/71o/KR3nD1w==}
+    engines: {node: '>=18'}
+
   fast-check@3.23.2:
     resolution: {integrity: sha512-h5+1OzzfCC3Ef7VbtKdcv7zsstUQwUDlYpUTvjeUsJAssPgLn7QzbboPtL5ro04Mq0rPOsMzl7q5hIbRs2wD1A==}
     engines: {node: '>=8.0.0'}
@@ -13364,6 +13371,8 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
+  fake-indexeddb@6.2.5: {}
+
   fast-check@3.23.2:
     dependencies:
       pure-rand: 6.1.0
diff --git a/src/components/ConflictResolver.tsx b/src/components/ConflictResolver.tsx
index 65217962..99a202f5 100644
--- a/src/components/ConflictResolver.tsx
+++ b/src/components/ConflictResolver.tsx
@@ -1,11 +1,24 @@
 'use client';
 
 import React, { useEffect, useId, useState } from 'react';
-import { ConflictRecord, ResolutionStrategy } from '@/lib/conflict/types';
+import { ConflictRecord, ResolutionStrategy, SyncConflictState } from '@/lib/conflict/types';
 import { motion, AnimatePresence } from 'framer-motion';
 import { X, AlertTriangle, ArrowRight, Save, History, Check } from 'lucide-react';
 import { useFocusTrap } from '@/hooks/useFocusTrap';
 
+const STATE_STYLES: Record<SyncConflictState, string> = {
+  pending: 'bg-yellow-500/10 text-yellow-500 border-yellow-500/30',
+  conflicted: 'bg-orange-500/10 text-orange-500 border-orange-500/30',
+  resolved: 'bg-emerald-500/10 text-emerald-500 border-emerald-500/30',
+};
+
+const formatVector = (vector?: Record<string, number>): string => {
+  if (!vector || Object.keys(vector).length === 0) return '—';
+  return Object.entries(vector)
+    .map(([replica, count]) => `${replica.slice(0, 8)}:${count}`)
+    .join(', ');
+};
+
 interface ConflictResolverProps {
   conflict: ConflictRecord<any>;
   onResolve: (strategy: ResolutionStrategy, manualData?: any) => void;
@@ -64,6 +77,11 @@ export const ConflictResolver: React.FC<ConflictResolverProps> = ({
                 <p className="text-sm text-gray-400">
                   Resolution required for {conflict.entityType}
                 </p>
+                <span
+                  className={`inline-block mt-2 px-2 py-0.5 rounded-full text-[10px] font-bold uppercase tracking-wider border ${STATE_STYLES[conflict.state ?? 'conflicted']}`}
+                >
+                  {conflict.state ?? 'conflicted'}
+                </span>
               </div>
             </div>
             <button
@@ -87,6 +105,12 @@ export const ConflictResolver: React.FC<ConflictResolverProps> = ({
                     : 'border-white/5 bg-white/5 hover:border-white/20'
                 }`}
               >
+                <div className="mb-2 text-[10px] text-gray-500">
+                  version vector:{' '}
+                  <span className="font-mono text-gray-400">
+                    {formatVector(conflict.localVersionVector)}
+                  </span>
+                </div>
                 <div className="flex items-center justify-between mb-3">
                   <span className="text-xs font-bold uppercase tracking-wider text-orange-500">
                     Local Version
@@ -112,6 +136,12 @@ export const ConflictResolver: React.FC<ConflictResolverProps> = ({
                     : 'border-white/5 bg-white/5 hover:border-white/20'
                 }`}
               >
+                <div className="mb-2 text-[10px] text-gray-500">
+                  version vector:{' '}
+                  <span className="font-mono text-gray-400">
+                    {formatVector(conflict.remoteVersionVector)}
+                  </span>
+                </div>
                 <div className="flex items-center justify-between mb-3">
                   <span className="text-xs font-bold uppercase tracking-wider text-blue-500">
                     Remote Version
diff --git a/src/constants/app.constants.ts b/src/constants/app.constants.ts
index 9a64f83f..c385f0e3 100644
--- a/src/constants/app.constants.ts
+++ b/src/constants/app.constants.ts
@@ -10,6 +10,27 @@ export const RECONNECT_DELAY_MS = 1000;
 export const MAX_TREND_POINTS = 200;
 export const MAX_RETRIES = 3;
 
+// Offline sync (deterministic, idempotent, resumable)
+export const SYNC_BATCH_SIZE = 20;
+/** Max delivery attempts per offline operation before it is dead-lettered. */
+export const SYNC_MAX_RETRY_ATTEMPTS = 3;
+/** Base delay (ms) for exponential backoff between retries. */
+export const SYNC_BACKOFF_BASE_MS = 500;
+/** Cap (ms) for exponential backoff so retries never spin forever. */
+export const SYNC_BACKOFF_CAP_MS = 10000;
+/** Retention window (ms) for acknowledged operations before GC (7 days). */
+export const SYNC_RETENTION_MS = 7 * 24 * 60 * 60 * 1000;
+/** Retention window (ms) for dead-lettered operations before GC (30 days). */
+export const DEAD_LETTER_RETENTION_MS = 30 * 24 * 60 * 60 * 1000;
+/** Background sync tag used by the service worker to trigger a drain. */
+export const SYNC_BACKGROUND_TAG = 'teachlink-offline-sync';
+
+export const SYNC_CONFLICT_STATES = {
+  PENDING: 'pending',
+  CONFLICTED: 'conflicted',
+  RESOLVED: 'resolved',
+} as const;
+
 // API Timeouts
 export const API_TIMEOUT_DEFAULT = 10000;
 export const API_TIMEOUT_UPLOAD = 60000;
diff --git a/src/hooks/useOfflineMode.tsx b/src/hooks/useOfflineMode.tsx
index b48d17b3..e60d8664 100644
--- a/src/hooks/useOfflineMode.tsx
+++ b/src/hooks/useOfflineMode.tsx
@@ -8,7 +8,10 @@ import {
   OfflineProgressRecord,
   SyncResult,
   SyncConflict,
+  SyncStatus,
 } from '../services/offlineSync';
+import { incrementVersionVector } from '../lib/conflict/resolver';
+import { syncEngine } from '../store/synchronizationEngine';
 
 export interface DownloadCourseInput {
   id: string;
@@ -156,7 +159,12 @@ export const useOfflineMode = () => {
       }
 
       const existing = await storageRef.current.getProgress(courseId, moduleId);
-      const version = existing?.version ? existing.version + 1 : 1;
+      const replicaId = await storageRef.current.getReplicaId();
+      const version = (existing?.version ?? 0) + 1;
+      const logicalClock = (existing?.logicalClock ?? 0) + 1;
+      // Deterministic per-record versioning: base the new vector on the last
+      // known state so merges are stable regardless of device clock drift.
+      const versionVector = incrementVersionVector(existing?.versionVector ?? {}, replicaId);
       const record: OfflineProgressRecord = {
         courseId,
         moduleId,
@@ -165,6 +173,9 @@ export const useOfflineMode = () => {
         updatedAt: new Date().toISOString(),
         synced: false,
         version,
+        logicalClock,
+        updatedBy: replicaId,
+        versionVector,
       };
 
       await storageRef.current.saveProgress(record);
@@ -186,7 +197,51 @@ export const useOfflineMode = () => {
 
   const syncData = useCallback(async (): Promise<SyncResult> => {
     if (!syncRef.current) throw new Error('Offline mode not initialized');
-    return await syncRef.current.syncData({ resolveConflicts: 'auto' });
+    const result = await syncRef.current.syncData({ resolveConflicts: 'auto' });
+
+    // Reconcile the persisted store after each drain so other tabs and a
+    // restarted app observe the same sync state.
+    try {
+      const status = await syncRef.current.getSyncStatus();
+      await syncEngine.recordDrainResult(
+        {
+          success: result.success,
+          syncedItems: result.syncedItems,
+          conflicts: result.conflicts.length,
+          lastSyncTime: result.lastSyncTime,
+        },
+        status.pending,
+      );
+    } catch (error) {
+      // Store reconciliation is best-effort; the drain itself already succeeded.
+      console.warn('Failed to reconcile sync state', error);
+    }
+
+    return result;
+  }, []);
+
+  const getSyncStatus = useCallback(async (): Promise<SyncStatus> => {
+    if (!syncRef.current) {
+      return {
+        isSyncing: false,
+        pending: 0,
+        conflicted: 0,
+        resolved: 0,
+        deadLetter: 0,
+        lastSyncTime: null,
+      };
+    }
+    return await syncRef.current.getSyncStatus();
+  }, []);
+
+  const getDeadLetterCount = useCallback(async (): Promise<number> => {
+    if (!syncRef.current) return 0;
+    return await syncRef.current.getDeadLetterCount();
+  }, []);
+
+  const retryDeadLetter = useCallback(async (id: string): Promise<boolean> => {
+    if (!syncRef.current) return false;
+    return await syncRef.current.retryDeadLetter(id);
   }, []);
 
   const getStorageInfo = useCallback(async () => {
@@ -243,6 +298,9 @@ export const useOfflineMode = () => {
       getProgress,
       getCourseProgress,
       syncData,
+      getSyncStatus,
+      getDeadLetterCount,
+      retryDeadLetter,
       getStorageInfo,
       getPendingSyncCount,
       getPendingConflicts,
@@ -262,6 +320,9 @@ export const useOfflineMode = () => {
       getProgress,
       getCourseProgress,
       syncData,
+      getSyncStatus,
+      getDeadLetterCount,
+      retryDeadLetter,
       getStorageInfo,
       getPendingSyncCount,
       getPendingConflicts,
diff --git a/src/hooks/useOfflineSync.ts b/src/hooks/useOfflineSync.ts
index 0618c98e..82e5da5e 100644
--- a/src/hooks/useOfflineSync.ts
+++ b/src/hooks/useOfflineSync.ts
@@ -2,16 +2,48 @@
 
 import { useState, useEffect, useCallback } from 'react';
 import { createLogger } from '@/lib/logging';
+import { SyncConflict } from '@/services/offlineSync';
 
 const logger = createLogger('use-offline-sync');
 
+/** Deterministic conflict state surfaced to the UI by the offline hooks. */
+export interface ConflictState {
+  pending: number;
+  conflicted: number;
+  resolved: number;
+}
+
+export interface OfflineSyncStatusSnapshot extends ConflictState {
+  deadLetter: number;
+}
+
+/** Message posted by the service worker when a background sync fires. */
+export const OFFLINE_SYNC_REQUESTED = 'OFFLINE_SYNC_REQUESTED';
+
 /**
- * Hook to manage offline state and handle background/foreground syncing when connectivity returns
+ * Hook to manage offline state and handle background/foreground syncing when
+ * connectivity returns. Exposes the deterministic `pending` / `conflicted` /
+ * `resolved` conflict state consumed by the `ConflictResolver` component.
+ *
+ * @param syncCallback   Invoked (online only) whenever a sync is triggered.
+ * @param getStatus      Optional provider returning live conflict/dead-letter
+ *                       counts from the offline stores (e.g. useOfflineMode's
+ *                       getSyncStatus). When omitted the states stay at zero.
  */
-export function useOfflineSync(syncCallback?: () => Promise<void>) {
+export function useOfflineSync(
+  syncCallback?: () => Promise<void>,
+  getStatus?: () => Promise<OfflineSyncStatusSnapshot>,
+) {
   const [isOffline, setIsOffline] = useState<boolean>(false);
   const [isSyncing, setIsSyncing] = useState<boolean>(false);
   const [lastSynced, setLastSynced] = useState<Date | null>(null);
+  const [conflictState, setConflictState] = useState<ConflictState>({
+    pending: 0,
+    conflicted: 0,
+    resolved: 0,
+  });
+  const [deadLetterCount, setDeadLetterCount] = useState<number>(0);
+  const [conflicts, setConflicts] = useState<SyncConflict[]>([]);
 
   // Initial offline check
   useEffect(() => {
@@ -20,6 +52,22 @@ export function useOfflineSync(syncCallback?: () => Promise<void>) {
     }
   }, []);
 
+  /** Refreshes the deterministic conflict state from the offline stores. */
+  const refreshStatus = useCallback(async () => {
+    if (!getStatus) return;
+    try {
+      const status = await getStatus();
+      setConflictState({
+        pending: status.pending,
+        conflicted: status.conflicted,
+        resolved: status.resolved,
+      });
+      setDeadLetterCount(status.deadLetter);
+    } catch (error) {
+      logger.error('Failed to refresh offline sync status', { error });
+    }
+  }, [getStatus]);
+
   const triggerSync = useCallback(async () => {
     if (isOffline) return;
 
@@ -36,12 +84,13 @@ export function useOfflineSync(syncCallback?: () => Promise<void>) {
       }
 
       setLastSynced(new Date());
+      await refreshStatus();
     } catch (error) {
       logger.error('Offline synchronization failed', { error });
     } finally {
       setIsSyncing(false);
     }
-  }, [isOffline, syncCallback]);
+  }, [isOffline, syncCallback, refreshStatus]);
 
   useEffect(() => {
     const handleOnline = () => {
@@ -57,5 +106,26 @@ export function useOfflineSync(syncCallback?: () => Promise<void>) {
     };
   }, [triggerSync]);
 
-  return { isOffline, isSyncing, lastSynced, triggerSync };
+  // Service worker background sync: drain the offline queue when connectivity
+  // returns even if the tab is backgrounded.
+  useEffect(() => {
+    const handleMessage = (event: MessageEvent) => {
+      if (event.data?.type === OFFLINE_SYNC_REQUESTED) {
+        triggerSync();
+      }
+    };
+    navigator.serviceWorker?.addEventListener('message', handleMessage);
+    return () => navigator.serviceWorker?.removeEventListener('message', handleMessage);
+  }, [triggerSync]);
+
+  return {
+    isOffline,
+    isSyncing,
+    lastSynced,
+    triggerSync,
+    refreshStatus,
+    conflictState,
+    deadLetterCount,
+    conflicts,
+  };
 }
diff --git a/src/lib/conflict/__tests__/resolver.test.ts b/src/lib/conflict/__tests__/resolver.test.ts
new file mode 100644
index 00000000..a335f0cc
--- /dev/null
+++ b/src/lib/conflict/__tests__/resolver.test.ts
@@ -0,0 +1,190 @@
+import { describe, it, expect } from 'vitest';
+import {
+  compareVersionVectors,
+  mergeVersionVectors,
+  incrementVersionVector,
+  detectConflict,
+  resolveConflict,
+  resolveByEntityType,
+  createConflictRecord,
+} from '../resolver';
+import { ProgressData } from '../types';
+
+const progress = (overrides: Partial<ProgressData> = {}): ProgressData => ({
+  progress: 40,
+  completed: false,
+  updatedAt: '2026-01-01T00:00:00.000Z',
+  version: 1,
+  logicalClock: 1,
+  updatedBy: 'replica-a',
+  versionVector: { 'replica-a': 1 },
+  ...overrides,
+});
+
+describe('compareVersionVectors', () => {
+  it('returns equal for identical vectors', () => {
+    expect(compareVersionVectors({ a: 1, b: 2 }, { a: 1, b: 2 })).toBe('equal');
+  });
+
+  it('detects a dominating b', () => {
+    expect(compareVersionVectors({ a: 2, b: 1 }, { a: 1, b: 1 })).toBe('a-dominates');
+  });
+
+  it('detects b dominating a', () => {
+    expect(compareVersionVectors({ a: 1 }, { a: 1, b: 1 })).toBe('b-dominates');
+  });
+
+  it('detects concurrent vectors (neither dominates)', () => {
+    expect(compareVersionVectors({ a: 1 }, { b: 1 })).toBe('concurrent');
+    expect(compareVersionVectors({ a: 2 }, { b: 2 })).toBe('concurrent');
+  });
+
+  it('treats missing entries as zero', () => {
+    expect(compareVersionVectors({}, { a: 1 })).toBe('b-dominates');
+    expect(compareVersionVectors({ a: 0 }, {})).toBe('equal');
+  });
+});
+
+describe('mergeVersionVectors / incrementVersionVector', () => {
+  it('merges element-wise max, commutatively', () => {
+    expect(mergeVersionVectors({ a: 1, b: 2 }, { a: 3, c: 1 })).toEqual({ a: 3, b: 2, c: 1 });
+    expect(mergeVersionVectors({ a: 3, c: 1 }, { a: 1, b: 2 })).toEqual({ a: 3, b: 2, c: 1 });
+  });
+
+  it('increments only the given replica', () => {
+    expect(incrementVersionVector({ a: 1, b: 2 }, 'b')).toEqual({ a: 1, b: 3 });
+    expect(incrementVersionVector({}, 'c')).toEqual({ c: 1 });
+  });
+});
+
+describe('detectConflict', () => {
+  it('does not flag a conflict when local dominates remote (local is strictly newer)', () => {
+    const local = progress({ versionVector: { 'replica-a': 2 } });
+    const remote = progress({ versionVector: { 'replica-a': 1 } });
+    expect(detectConflict(local, remote)).toBe(false);
+  });
+
+  it('does not flag a conflict when remote dominates local', () => {
+    const local = progress({ versionVector: { 'replica-a': 1 } });
+    const remote = progress({ versionVector: { 'replica-a': 1, 'replica-b': 1 } });
+    expect(detectConflict(local, remote)).toBe(false);
+  });
+
+  it('flags a conflict for concurrent vectors regardless of wall-clock skew', () => {
+    // Remote has an EARLIER wall clock but a concurrent vector — clock drift
+    // must not decide the outcome.
+    const local = progress({
+      updatedAt: '2026-01-02T00:00:00.000Z',
+      versionVector: { 'replica-a': 1 },
+    });
+    const remote = progress({
+      updatedAt: '2026-01-01T00:00:00.000Z',
+      versionVector: { 'replica-b': 1 },
+    });
+    expect(detectConflict(local, remote)).toBe(true);
+  });
+
+  it('falls back to timestamp/version comparison for legacy records without vectors', () => {
+    const local = progress({ versionVector: undefined, updatedAt: '2026-01-01T00:00:00.000Z', version: 1 });
+    const remote = progress({ versionVector: undefined, updatedAt: '2026-01-02T00:00:00.000Z', version: 2 });
+    expect(detectConflict(local, remote)).toBe(true);
+
+    const newerLocal = progress({ versionVector: undefined, updatedAt: '2026-01-03T00:00:00.000Z', version: 3 });
+    expect(detectConflict(newerLocal, remote)).toBe(false);
+  });
+});
+
+describe('resolveConflict (deterministic merge)', () => {
+  it('is deterministic across reordered inputs (commutative)', () => {
+    const a = progress({
+      progress: 60,
+      completed: true,
+      updatedAt: '2026-01-05T00:00:00.000Z',
+      version: 7,
+      logicalClock: 7,
+      versionVector: { 'replica-a': 3, 'replica-b': 1 },
+    });
+    const b = progress({
+      progress: 40,
+      completed: false,
+      updatedAt: '2026-01-02T00:00:00.000Z',
+      version: 4,
+      logicalClock: 4,
+      versionVector: { 'replica-a': 1, 'replica-b': 2 },
+    });
+
+    const forward = resolveConflict(a, b, 'merge', 'course_progress');
+    const backward = resolveConflict(b, a, 'merge', 'course_progress');
+    expect(forward).toEqual(backward);
+  });
+
+  it('merges progress by max and completion by OR, advancing the logical clock', () => {
+    const local = progress({ progress: 30, completed: false, versionVector: { a: 1 }, logicalClock: 1 });
+    const remote = progress({ progress: 70, completed: true, versionVector: { b: 1 }, logicalClock: 5 });
+
+    const merged = resolveConflict(local, remote, 'merge', 'course_progress');
+    expect(merged.progress).toBe(70);
+    expect(merged.completed).toBe(true);
+    expect(merged.version).toBe(Math.max(1, 1) + 1);
+    expect(merged.logicalClock).toBe(6);
+    expect(merged.versionVector).toEqual({ a: 1, b: 1 });
+  });
+
+  it('is stable under device clock skew', () => {
+    // Device A thinks it is 2026, device B thinks it is 2024.
+    const local = progress({
+      progress: 50,
+      updatedAt: '2026-06-01T00:00:00.000Z',
+      versionVector: { a: 1 },
+    });
+    const remote = progress({
+      progress: 55,
+      updatedAt: '2024-01-01T00:00:00.000Z',
+      versionVector: { b: 1 },
+    });
+
+    const merged = resolveConflict(local, remote, 'merge', 'course_progress');
+    expect(merged.progress).toBe(55);
+    // Deterministic: does not depend on which wall clock is "newer".
+    expect(merged).toEqual(resolveConflict(remote, local, 'merge', 'course_progress'));
+  });
+
+  it('honors local/remote strategies directly', () => {
+    const local = progress({ progress: 10 });
+    const remote = progress({ progress: 90 });
+    expect(resolveConflict(local, remote, 'local', 'course_progress').progress).toBe(10);
+    expect(resolveConflict(local, remote, 'remote', 'course_progress').progress).toBe(90);
+  });
+});
+
+describe('resolveByEntityType (per-entity strategies)', () => {
+  it('uses the course_progress strategy for progress-like payloads', () => {
+    const local = progress({ progress: 20, completed: false });
+    const remote = progress({ progress: 80, completed: true });
+    const merged = resolveByEntityType('course_progress', local, remote);
+    expect(merged.progress).toBe(80);
+    expect(merged.completed).toBe(true);
+  });
+
+  it('falls back to a generic shallow merge for unknown entity types', () => {
+    const local = { title: 'a', tags: ['x'] };
+    const remote = { title: 'b', rating: 5 };
+    expect(resolveByEntityType('unknown', local, remote)).toEqual({ title: 'b', tags: ['x'], rating: 5 });
+  });
+});
+
+describe('createConflictRecord', () => {
+  it('captures both version vectors and surfaces the conflicted state', () => {
+    const local = progress({ versionVector: { a: 2 } });
+    const remote = progress({ versionVector: { b: 1 } });
+
+    const record = createConflictRecord('course_progress', 'c1:m1', local, remote);
+    expect(record.entityType).toBe('course_progress');
+    expect(record.entityKey).toBe('c1:m1');
+    expect(record.state).toBe('conflicted');
+    expect(record.resolved).toBe(false);
+    expect(record.localVersionVector).toEqual({ a: 2 });
+    expect(record.remoteVersionVector).toEqual({ b: 1 });
+    expect(record.history[0].action).toBe('CREATED');
+  });
+});
diff --git a/src/lib/conflict/resolver.ts b/src/lib/conflict/resolver.ts
index 4491dc9c..e756a39e 100644
--- a/src/lib/conflict/resolver.ts
+++ b/src/lib/conflict/resolver.ts
@@ -1,16 +1,158 @@
-import { ConflictRecord, ResolutionStrategy, ProgressData } from './types';
+import {
+  ConflictRecord,
+  ResolutionStrategy,
+  ProgressData,
+  VersionVector,
+  VectorComparison,
+  MergeStrategy,
+  MergeEntityType,
+} from './types';
 
-export type { ConflictRecord, ResolutionStrategy } from './types';
+export type { ConflictRecord, ResolutionStrategy, VersionVector, VectorComparison } from './types';
+
+// ---------------------------------------------------------------------------
+// Version vector helpers
+// ---------------------------------------------------------------------------
 
 /**
- * Detects if a conflict exists between local and remote data based on timestamps and versions.
+ * Compares two version vectors deterministically.
+ *
+ * Returns:
+ * - `equal`          both vectors carry the same counters
+ * - `a-dominates`    `a` happened-after `b` (no conflict, `a` wins)
+ * - `b-dominates`    `b` happened-after `a` (no conflict, `b` wins)
+ * - `concurrent`     neither dominates -> genuine conflict
  */
-export function detectConflict<T extends { updatedAt: string; version?: number }>(
+export function compareVersionVectors(a: VersionVector, b: VersionVector): VectorComparison {
+  const keys = new Set<string>([...Object.keys(a), ...Object.keys(b)]);
+  let aGreater = false;
+  let bGreater = false;
+
+  for (const key of keys) {
+    const aValue = a[key] ?? 0;
+    const bValue = b[key] ?? 0;
+    if (aValue > bValue) aGreater = true;
+    else if (bValue > aValue) bGreater = true;
+  }
+
+  if (aGreater && bGreater) return 'concurrent';
+  if (aGreater) return 'a-dominates';
+  if (bGreater) return 'b-dominates';
+  return 'equal';
+}
+
+/** Element-wise maximum of two version vectors (commutative, deterministic). */
+export function mergeVersionVectors(a: VersionVector, b: VersionVector): VersionVector {
+  const keys = new Set<string>([...Object.keys(a), ...Object.keys(b)]);
+  const merged: VersionVector = {};
+  for (const key of keys) {
+    merged[key] = Math.max(a[key] ?? 0, b[key] ?? 0);
+  }
+  return merged;
+}
+
+/** Returns a new vector with the given replica's counter incremented. */
+export function incrementVersionVector(vector: VersionVector, replicaId: string): VersionVector {
+  return {
+    ...vector,
+    [replicaId]: (vector[replicaId] ?? 0) + 1,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Per-entity-type deterministic merge strategies
+// ---------------------------------------------------------------------------
+
+/**
+ * Deterministic merge for course progress.
+ *
+ * Progress is merged by taking the maximum progress, OR-ing completion, and
+ * advancing the version/logical clock by the max of both sides. All inputs are
+ * compared by value, so the result is identical regardless of which side is
+ * passed first or which device performed the merge.
+ */
+function mergeProgressData(local: ProgressData, remote: ProgressData): ProgressData {
+  const version = Math.max(local.version ?? 0, remote.version ?? 0) + 1;
+  const logicalClock = Math.max(local.logicalClock ?? 0, remote.logicalClock ?? 0) + 1;
+  const mergedBy = [local.updatedBy, remote.updatedBy].filter(Boolean).sort().join(',');
+  return {
+    progress: Math.max(local.progress, remote.progress),
+    completed: local.completed || remote.completed,
+    // Deterministic choice independent of argument order: the lexicographically
+    // greater ISO timestamp (ISO strings compare correctly lexicographically).
+    updatedAt: local.updatedAt >= remote.updatedAt ? local.updatedAt : remote.updatedAt,
+    version,
+    logicalClock,
+    updatedBy: mergedBy || undefined,
+    versionVector: mergeVersionVectors(local.versionVector ?? {}, remote.versionVector ?? {}),
+  };
+}
+
+/**
+ * Generic deterministic merge: field-level union preferring the higher version
+ * vector, falling back to the "remote" side for equal precedence.
+ */
+function mergeGeneric<T>(local: T, remote: T): T {
+  return { ...local, ...remote };
+}
+
+export const MERGE_STRATEGIES: Record<MergeEntityType, MergeStrategy> = {
+  course_progress: mergeProgressData as MergeStrategy,
+  generic: mergeGeneric,
+};
+
+function isProgressData(data: any): data is ProgressData {
+  return (
+    data &&
+    typeof data.progress === 'number' &&
+    typeof data.completed === 'boolean' &&
+    typeof data.updatedAt === 'string'
+  );
+}
+
+/** Resolve using the per-entity-type strategy (falls back to shape detection, then generic). */
+export function resolveByEntityType<T>(entityType: string, local: T, remote: T): T {
+  if (entityType !== 'generic') {
+    const strategy = (MERGE_STRATEGIES as Record<string, MergeStrategy>)[entityType];
+    if (strategy) return strategy(local, remote) as T;
+  }
+  // Progress-like payloads always use the deterministic progress merge so the
+  // outcome is stable regardless of which caller invoked the resolver.
+  if (isProgressData(local) && isProgressData(remote)) {
+    return MERGE_STRATEGIES.course_progress(local, remote) as unknown as T;
+  }
+  return MERGE_STRATEGIES.generic(local, remote) as T;
+}
+
+// ---------------------------------------------------------------------------
+// Conflict detection & resolution
+// ---------------------------------------------------------------------------
+
+/**
+ * Detects a conflict between local and remote data.
+ *
+ * When both sides carry version vectors the comparison is deterministic and
+ * immune to clock drift: only *concurrent* vectors produce a conflict. Legacy
+ * records without vectors fall back to the previous timestamp/version
+ * comparison.
+ */
+export function detectConflict<T extends { updatedAt: string; version?: number; versionVector?: VersionVector }>(
   local: T,
   remote: T,
 ): boolean {
-  // If remote is newer than local, we have a potential conflict
-  // (Assuming local changes were made while remote was already newer)
+  const localVector = local.versionVector;
+  const remoteVector = remote.versionVector;
+
+  if (
+    localVector &&
+    remoteVector &&
+    Object.keys(localVector).length > 0 &&
+    Object.keys(remoteVector).length > 0
+  ) {
+    return compareVersionVectors(localVector, remoteVector) === 'concurrent';
+  }
+
+  // Fallback for legacy records without version vectors: timestamp LWW.
   const localTime = new Date(local.updatedAt).getTime();
   const remoteTime = new Date(remote.updatedAt).getTime();
 
@@ -27,17 +169,25 @@ export function detectConflict<T extends { updatedAt: string; version?: number }
 
 /**
  * Resolves a conflict based on the chosen strategy.
+ *
+ * `merge` uses the deterministic per-entity-type strategy so the outcome is
+ * stable across devices, reordered inputs, and clock skew.
  */
-export function resolveConflict<T>(local: T, remote: T, strategy: ResolutionStrategy): T {
+export function resolveConflict<T>(
+  local: T,
+  remote: T,
+  strategy: ResolutionStrategy,
+  entityType?: string,
+): T {
   switch (strategy) {
     case 'local':
       return local;
     case 'remote':
       return remote;
     case 'merge':
-      return mergeData(local, remote);
+      return resolveByEntityType(entityType ?? 'generic', local, remote);
     case 'manual':
-      // Manual resolution handled by UI, default to remote if called programmatically
+      // Manual resolution is handled by the UI; default to remote if called programmatically.
       return remote;
     default:
       return remote;
@@ -45,36 +195,8 @@ export function resolveConflict<T>(local: T, remote: T, strategy: ResolutionStra
 }
 
 /**
- * Merges two data objects. Specifically handles ProgressData.
- */
-function mergeData<T>(local: T, remote: T): T {
-  // If it's progress data, we merge by taking the maximum progress and completion status
-  if (isProgressData(local) && isProgressData(remote)) {
-    const merged: ProgressData = {
-      ...remote,
-      progress: Math.max(local.progress, remote.progress),
-      completed: local.completed || remote.completed,
-      updatedAt: new Date().toISOString(),
-      version: Math.max(local.version || 0, remote.version || 0) + 1,
-    };
-    return merged as unknown as T;
-  }
-
-  // Generic merge (last write wins on field level if they were objects, but here we just return remote)
-  return { ...local, ...remote };
-}
-
-function isProgressData(data: any): data is ProgressData {
-  return (
-    data &&
-    typeof data.progress === 'number' &&
-    typeof data.completed === 'boolean' &&
-    typeof data.updatedAt === 'string'
-  );
-}
-
-/**
- * Creates a new conflict record with initial history.
+ * Creates a new conflict record with initial history and the version vectors
+ * of both sides so the UI can present a deterministic comparison.
  */
 export function createConflictRecord<T>(
   entityType: string,
@@ -92,6 +214,9 @@ export function createConflictRecord<T>(
     timestamp: new Date().toISOString(),
     strategy: 'manual',
     resolved: false,
+    state: 'conflicted',
+    localVersionVector: (localData as { versionVector?: VersionVector })?.versionVector,
+    remoteVersionVector: (remoteData as { versionVector?: VersionVector })?.versionVector,
     history: [
       {
         timestamp: new Date().toISOString(),
diff --git a/src/lib/conflict/types.ts b/src/lib/conflict/types.ts
index 370ee3db..bb128023 100644
--- a/src/lib/conflict/types.ts
+++ b/src/lib/conflict/types.ts
@@ -1,5 +1,30 @@
 export type ResolutionStrategy = 'local' | 'remote' | 'merge' | 'manual';
 
+/**
+ * Version vector used for deterministic conflict detection.
+ *
+ * A vector maps a replica/device identifier to the number of operations that
+ * replica has contributed. Two vectors are compared entry-wise:
+ * - one dominates the other -> that side happened-after, no conflict
+ * - neither dominates (both have entries the other lacks) -> concurrent -> conflict
+ *
+ * Unlike wall-clock timestamps, version vectors are immune to clock drift
+ * between devices, which makes resolution deterministic across reordered and
+ * clock-skewed inputs.
+ */
+export type VersionVector = Record<string, number>;
+
+/** Result of comparing two version vectors. */
+export type VectorComparison = 'equal' | 'a-dominates' | 'b-dominates' | 'concurrent';
+
+/**
+ * UI-facing state of an offline operation / conflict record.
+ * - `pending`:   queued locally, not yet acknowledged by the server
+ * - `conflicted`: waiting for user resolution
+ * - `resolved`:  conflict has been resolved (or record synced successfully)
+ */
+export type SyncConflictState = 'pending' | 'conflicted' | 'resolved';
+
 export interface ConflictRecord<T> {
   id: string;
   entityType: string;
@@ -9,6 +34,10 @@ export interface ConflictRecord<T> {
   timestamp: string;
   strategy: ResolutionStrategy;
   resolved: boolean;
+  /** `pending` | `conflicted` | `resolved` — surfaced to the UI by offline hooks. */
+  state: SyncConflictState;
+  localVersionVector?: VersionVector;
+  remoteVersionVector?: VersionVector;
   history: Array<{
     timestamp: string;
     action: string;
@@ -19,9 +48,27 @@ export interface ConflictRecord<T> {
 export interface SyncMetadata {
   updatedAt: string;
   version: number;
+  /** Replica/device that produced the last change. */
+  updatedBy?: string;
+  /** Logical clock (Lamport) — advances monotonically, immune to clock drift. */
+  logicalClock?: number;
+  versionVector?: VersionVector;
 }
 
 export interface ProgressData extends SyncMetadata {
   progress: number;
   completed: boolean;
 }
+
+/** Entity types understood by the deterministic merge engine. */
+export type MergeEntityType = 'course_progress' | 'generic';
+
+/**
+ * Per-entity-type deterministic merge strategy.
+ *
+ * A strategy is a pure function of (local, remote) that returns the merged
+ * record. It MUST be deterministic (no dependence on wall-clock ordering or
+ * argument order), so that the same inputs always produce the same output on
+ * every device.
+ */
+export type MergeStrategy<T = unknown> = (local: T, remote: T) => T;
diff --git a/src/lib/queue/index.ts b/src/lib/queue/index.ts
index f623a6ff..030a91ca 100644
--- a/src/lib/queue/index.ts
+++ b/src/lib/queue/index.ts
@@ -28,6 +28,8 @@ export interface QueueOptions {
   maxAttempts?: number;
   /** Base delay in ms for exponential backoff (default: 500). */
   retryDelay?: number;
+  /** Cap in ms for exponential backoff so retries never spin indefinitely (default: 10s). */
+  retryDelayCap?: number;
 }
 
 let _idCounter = 0;
@@ -51,6 +53,7 @@ export class TaskQueue {
       concurrency: options.concurrency ?? 3,
       maxAttempts: options.maxAttempts ?? 3,
       retryDelay: options.retryDelay ?? 500,
+      retryDelayCap: options.retryDelayCap ?? 10000,
     };
   }
 
@@ -99,6 +102,15 @@ export class TaskQueue {
     return true;
   }
 
+  /** Snapshot of queue health (pending/running/done/failed/dead-letter counts). */
+  getStats(): { pending: number; running: number; done: number; failed: number; deadLetter: number } {
+    const counts = { pending: 0, running: 0, done: 0, failed: 0, deadLetter: this.deadLetter.length };
+    for (const job of this.queue) {
+      counts[job.status] += 1;
+    }
+    return counts;
+  }
+
   private tick(): void {
     while (this.running < this.opts.concurrency) {
       const job = this.queue.find((j) => j.status === 'pending');
@@ -135,7 +147,10 @@ export class TaskQueue {
       } catch (err) {
         job.lastError = err instanceof Error ? err.message : String(err);
         if (attempt < job.maxAttempts) {
-          const backoff = this.opts.retryDelay * Math.pow(2, attempt - 1);
+          const backoff = Math.min(
+            this.opts.retryDelayCap,
+            this.opts.retryDelay * Math.pow(2, attempt - 1),
+          );
           await delay(backoff);
         }
       }
diff --git a/src/serviceWorker.ts b/src/serviceWorker.ts
index 4a65d41f..4e8b029d 100644
--- a/src/serviceWorker.ts
+++ b/src/serviceWorker.ts
@@ -118,6 +118,25 @@ const bgSyncPlugin = new BackgroundSyncPlugin('teachLinkSyncQueue', {
   maxRetentionTime: 24 * 60, // 24 hours in minutes
 });
 
+// Drains the deterministic offline queue (IndexedDB `teachlink-offline`) when
+// connectivity returns. The client listens for OFFLINE_SYNC_REQUESTED and runs
+// its transactional, cursor-based drain.
+async function notifyClientsToDrain(): Promise<void> {
+  const clients = await self.clients.matchAll({
+    type: 'window',
+    includeUncontrolled: true,
+  });
+  for (const client of clients) {
+    client.postMessage({ type: 'OFFLINE_SYNC_REQUESTED' });
+  }
+}
+
+self.addEventListener('sync', (event) => {
+  if (event.tag === 'teachlink-offline-sync') {
+    event.waitUntil(notifyClientsToDrain());
+  }
+});
+
 // Lesson progress – PATCH /api/lessons/[id]/progress
 registerRoute(
   ({ url }) => url.pathname.match(/^\/api\/lessons\/[\w-]+\/progress$/),
diff --git a/src/services/__tests__/offlineSync.test.ts b/src/services/__tests__/offlineSync.test.ts
new file mode 100644
index 00000000..86f7fdb9
--- /dev/null
+++ b/src/services/__tests__/offlineSync.test.ts
@@ -0,0 +1,358 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import {
+  IDBFactory,
+  IDBKeyRange,
+  IDBCursor,
+  IDBCursorWithValue,
+  IDBDatabase,
+  IDBFactory as _IDBFactory,
+  IDBIndex,
+  IDBObjectStore,
+  IDBOpenDBRequest,
+  IDBRequest,
+  IDBTransaction,
+} from 'fake-indexeddb';
+import { OfflineStorage, OfflineSyncService, OfflineProgressRecord } from '@/services/offlineSync';
+import { SYNC_RETENTION_MS, DEAD_LETTER_RETENTION_MS } from '@/constants/app.constants';
+
+// The shared test-setup stubs IndexedDB; swap in the real fake implementation
+// so the offline stores actually persist. `window.indexedDB` is writable, the
+// other IDB globals are plain assignments.
+(globalThis as any).indexedDB = new IDBFactory();
+(globalThis as any).IDBKeyRange = IDBKeyRange;
+(globalThis as any).IDBCursor = IDBCursor;
+(globalThis as any).IDBCursorWithValue = IDBCursorWithValue;
+(globalThis as any).IDBDatabase = IDBDatabase;
+(globalThis as any).IDBFactory = _IDBFactory;
+(globalThis as any).IDBIndex = IDBIndex;
+(globalThis as any).IDBObjectStore = IDBObjectStore;
+(globalThis as any).IDBOpenDBRequest = IDBOpenDBRequest;
+(globalThis as any).IDBRequest = IDBRequest;
+(globalThis as any).IDBTransaction = IDBTransaction;
+
+vi.mock('@/services/offlineApi', () => ({
+  offlineApi: {
+    syncLessonProgress: vi.fn(),
+  },
+}));
+
+import { offlineApi } from '@/services/offlineApi';
+import { VersionVector } from '@/lib/conflict/types';
+
+const syncLessonProgressMock = vi.mocked(offlineApi.syncLessonProgress);
+
+let storage: OfflineStorage;
+let service: OfflineSyncService;
+
+const makeProgress = (
+  courseId = 'c1',
+  moduleId = 'm1',
+  progress = 50,
+  completed = false,
+  vector: VersionVector = { 'replica-a': 1 },
+): OfflineProgressRecord => ({
+  courseId,
+  moduleId,
+  progress,
+  completed,
+  updatedAt: new Date().toISOString(),
+  synced: false,
+  version: 1,
+  logicalClock: 1,
+  updatedBy: 'replica-a',
+  versionVector: vector,
+});
+
+const enqueueProgress = async (record: OfflineProgressRecord) => {
+  await storage.saveProgress(record);
+  return await service.enqueue('course_progress', record);
+};
+
+const okResponse = (record: OfflineProgressRecord) => ({
+  success: true,
+  data: { ...record, lessonId: record.moduleId },
+});
+
+beforeEach(async () => {
+  // Fresh in-memory database per test.
+  (globalThis as any).indexedDB = new IDBFactory();
+  syncLessonProgressMock.mockReset();
+
+  storage = new OfflineStorage();
+  await storage.init();
+  service = new OfflineSyncService(storage);
+});
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+describe('idempotent replay', () => {
+  it('applies a duplicate-delivered operation exactly once', async () => {
+    const record = makeProgress();
+    const item = await enqueueProgress(record);
+    syncLessonProgressMock.mockResolvedValueOnce(okResponse(record));
+
+    const first = await service.syncData({ retryAttempts: 1 });
+    expect(first.success).toBe(true);
+    expect(syncLessonProgressMock).toHaveBeenCalledTimes(1);
+    expect(await service.getQueue()).toHaveLength(0);
+
+    // Simulate a crash after the server applied the operation but before the
+    // queue entry was removed and the cursor advanced: the same operation id
+    // is delivered again.
+    const db = storage.getDb();
+    await db.put('syncQueue', item);
+    await db.put('syncMeta', { key: 'syncCursor', value: 0 });
+
+    const second = await service.syncData({ retryAttempts: 1 });
+    expect(second.success).toBe(true);
+    // Not re-sent: the ack dedupe map short-circuits replay.
+    expect(syncLessonProgressMock).toHaveBeenCalledTimes(1);
+    // The stale queue entry is reconciled away.
+    expect(await service.getQueue()).toHaveLength(0);
+  });
+
+  it('sends the client-generated operationId so the server can dedupe', async () => {
+    const record = makeProgress();
+    await enqueueProgress(record);
+    syncLessonProgressMock.mockResolvedValueOnce(okResponse(record));
+
+    await service.syncData({ retryAttempts: 1 });
+    const sent = syncLessonProgressMock.mock.calls[0][0];
+    expect(sent.operationId).toBeDefined();
+    expect(sent.operationId).toMatch(/^op-course_progress-/);
+  });
+});
+
+describe('transactional batch drain', () => {
+  it('rolls back the whole batch on a partial failure without diverging queue and store', async () => {
+    const r1 = makeProgress('c1', 'm1', 10);
+    const r2 = makeProgress('c2', 'm2', 20);
+    await enqueueProgress(r1);
+    await enqueueProgress(r2);
+
+    syncLessonProgressMock
+      .mockResolvedValueOnce(okResponse(r1))
+      .mockRejectedValueOnce(new Error('network down'));
+
+    const result = await service.syncData({ retryAttempts: 1 });
+    expect(result.success).toBe(false);
+    expect(result.errors).toHaveLength(1);
+
+    // Nothing committed: queue intact, no acks, progress untouched.
+    expect(await service.getQueue()).toHaveLength(2);
+    expect(await storage.getProgress('c1', 'm1')).toMatchObject({ synced: false });
+    expect(await storage.getProgress('c2', 'm2')).toMatchObject({ synced: false });
+    expect(await storage.getDb().getAll('ackedOps')).toHaveLength(0);
+
+    // Recovery: the drain resumes and eventually converges.
+    syncLessonProgressMock
+      .mockResolvedValueOnce(okResponse(r1))
+      .mockResolvedValueOnce(okResponse(r2));
+
+    const second = await service.syncData({ retryAttempts: 1 });
+    expect(second.success).toBe(true);
+    expect(await service.getQueue()).toHaveLength(0);
+    expect(await storage.getProgress('c1', 'm1')).toMatchObject({ synced: true });
+    expect(await storage.getProgress('c2', 'm2')).toMatchObject({ synced: true });
+    expect(await storage.getDb().getAll('ackedOps')).toHaveLength(2);
+  });
+
+  it('resumes from the persisted cursor after an app restart', async () => {
+    await enqueueProgress(makeProgress('c1', 'm1', 10));
+    await enqueueProgress(makeProgress('c2', 'm2', 20));
+    await enqueueProgress(makeProgress('c3', 'm3', 30));
+
+    syncLessonProgressMock.mockImplementation(async (payload: any) => ({
+      success: true,
+      data: { ...payload, lessonId: payload.moduleId },
+    }));
+
+    const first = await service.syncData({ retryAttempts: 1 });
+    expect(first.success).toBe(true);
+    expect(syncLessonProgressMock).toHaveBeenCalledTimes(3);
+
+    // A new change lands, then the app restarts.
+    await enqueueProgress(makeProgress('c4', 'm4', 40));
+
+    const storage2 = new OfflineStorage();
+    await storage2.init();
+    const service2 = new OfflineSyncService(storage2);
+
+    const second = await service2.syncData({ retryAttempts: 1 });
+    expect(second.success).toBe(true);
+    // Only the new operation was replayed — the cursor skipped drained work.
+    expect(syncLessonProgressMock).toHaveBeenCalledTimes(4);
+    expect(await service2.getQueue()).toHaveLength(0);
+  });
+
+  it('dead-letters operations that exhaust their retry cap', async () => {
+    const record = makeProgress('c1', 'm1', 50);
+    await enqueueProgress(record);
+
+    // Give the op a 2-attempt lifetime and pre-spend one attempt.
+    const db = storage.getDb();
+    const [item] = await service.getQueue();
+    await db.put('syncQueue', { ...item, maxAttempts: 2, attempts: 1 });
+
+    syncLessonProgressMock.mockRejectedValue(new Error('server 500'));
+
+    const result = await service.syncData({ retryAttempts: 1 });
+    expect(result.deadLettered).toBe(1);
+    expect(await service.getQueue()).toHaveLength(0);
+
+    const dead = await service.getDeadLetter();
+    expect(dead).toHaveLength(1);
+    expect(dead[0].status).toBe('dead');
+    expect(dead[0].lastError).toContain('server 500');
+
+    // Retrying re-enqueues it; once healthy it drains normally.
+    syncLessonProgressMock.mockResolvedValueOnce(okResponse(record));
+    expect(await service.retryDeadLetter(dead[0].id)).toBe(true);
+    const recovered = await service.syncData({ retryAttempts: 1 });
+    expect(recovered.success).toBe(true);
+    expect(await service.getDeadLetter()).toHaveLength(0);
+    expect(await service.getQueue()).toHaveLength(0);
+  });
+
+  it('retries within a drain using capped exponential backoff', async () => {
+    const record = makeProgress('c1', 'm1', 50);
+    await enqueueProgress(record);
+
+    syncLessonProgressMock
+      .mockRejectedValueOnce(new Error('flaky'))
+      .mockRejectedValueOnce(new Error('flaky'))
+      .mockResolvedValueOnce(okResponse(record));
+
+    const result = await service.syncData({
+      retryAttempts: 3,
+      backoffBaseMs: 5,
+      backoffCapMs: 20,
+      maxRetryAttempts: 5,
+    });
+
+    expect(syncLessonProgressMock).toHaveBeenCalledTimes(3);
+    expect(result.success).toBe(true);
+    expect(await service.getQueue()).toHaveLength(0);
+  });
+});
+
+describe('deterministic conflict resolution through the service', () => {
+  it('auto-merges concurrent changes using version vectors (clock-skew proof)', async () => {
+    const local = makeProgress('c1', 'm1', 30, false);
+    await enqueueProgress(local);
+
+    // Concurrent change from another device with an EARLIER wall clock.
+    const remote = {
+      ...local,
+      progress: 60,
+      completed: true,
+      updatedAt: '2026-01-01T00:00:00.000Z',
+      version: 5,
+      versionVector: { 'replica-b': 1 },
+      updatedBy: 'replica-b',
+    };
+    syncLessonProgressMock.mockResolvedValueOnce(okResponse(remote as OfflineProgressRecord));
+
+    const result = await service.syncData({ resolveConflicts: 'auto', retryAttempts: 1 });
+    expect(result.success).toBe(true);
+    expect(result.conflicts).toHaveLength(0);
+
+    const stored = await storage.getProgress('c1', 'm1');
+    expect(stored).toMatchObject({ progress: 60, completed: true, synced: true });
+    // Merged vector is the element-wise max of both sides.
+    expect(stored?.versionVector).toEqual({ 'replica-a': 1, 'replica-b': 1 });
+    expect(await service.getQueue()).toHaveLength(0);
+  });
+
+  it('surfaces manual conflicts to the UI and resolves them', async () => {
+    const local = makeProgress('c1', 'm1', 30, false);
+    await enqueueProgress(local);
+
+    const remote = {
+      ...local,
+      progress: 60,
+      versionVector: { 'replica-b': 1 },
+      updatedBy: 'replica-b',
+    };
+    syncLessonProgressMock.mockResolvedValueOnce(okResponse(remote as OfflineProgressRecord));
+
+    const result = await service.syncData({ resolveConflicts: 'manual', retryAttempts: 1 });
+    expect(result.success).toBe(true);
+    expect(result.conflicts).toHaveLength(1);
+
+    const pending = await service.getPendingConflicts();
+    expect(pending).toHaveLength(1);
+    expect(pending[0].state).toBe('conflicted');
+    expect(pending[0].entityType).toBe('course_progress');
+    expect(pending[0].localVersionVector).toEqual({ 'replica-a': 1 });
+    expect(pending[0].remoteVersionVector).toEqual({ 'replica-b': 1 });
+
+    // UI resolves toward remote.
+    await service.resolveConflict(pending[0].id, 'remote');
+    expect(await service.getPendingConflicts()).toHaveLength(0);
+
+    const stored = await storage.getProgress('c1', 'm1');
+    expect(stored).toMatchObject({ progress: 60, synced: true });
+
+    const status = await service.getSyncStatus();
+    expect(status.conflicted).toBe(0);
+    expect(status.resolved).toBe(1);
+  });
+});
+
+describe('retention / GC', () => {
+  it('garbage-collects acked and dead-lettered records past their retention windows', async () => {
+    const db = storage.getDb();
+    const oldAcked = new Date(Date.now() - SYNC_RETENTION_MS - 1000).toISOString();
+    const oldDead = new Date(Date.now() - DEAD_LETTER_RETENTION_MS - 1000).toISOString();
+    const fresh = new Date().toISOString();
+
+    await db.put('ackedOps', { operationId: 'op-old', entityKey: 'c1:m1', ackedAt: oldAcked });
+    await db.put('ackedOps', { operationId: 'op-fresh', entityKey: 'c1:m1', ackedAt: fresh });
+    await db.put('deadLetter', {
+      id: 'dl-old',
+      operationId: 'op-dl',
+      entityKey: 'c1:m1',
+      failedAt: oldDead,
+      lastError: 'exhausted',
+      seq: 99,
+      type: 'course_progress',
+      timestamp: oldDead,
+      version: 1,
+      versionVector: { 'replica-a': 1 },
+      updatedBy: 'replica-a',
+      status: 'dead',
+      attempts: 3,
+      maxAttempts: 3,
+    });
+
+    const removed = await service.gcAckedRecords();
+    expect(removed.acked).toBe(1);
+    expect(await db.get('ackedOps', 'op-old')).toBeUndefined();
+    expect(await db.get('ackedOps', 'op-fresh')).toBeDefined();
+    expect(await db.getAll('deadLetter')).toHaveLength(0);
+  });
+
+  it('reports UI-facing sync status counts', async () => {
+    await enqueueProgress(makeProgress('c1', 'm1', 10));
+    await enqueueProgress(makeProgress('c2', 'm2', 20));
+
+    const status = await service.getSyncStatus();
+    expect(status.pending).toBe(2);
+    expect(status.conflicted).toBe(0);
+    expect(status.resolved).toBe(0);
+    expect(status.deadLetter).toBe(0);
+
+    syncLessonProgressMock.mockImplementation(async (payload: any) => ({
+      success: true,
+      data: { ...payload, lessonId: payload.moduleId },
+    }));
+    await service.syncData({ retryAttempts: 1 });
+
+    const after = await service.getSyncStatus();
+    expect(after.pending).toBe(0);
+    expect(after.lastSyncTime).toBeDefined();
+  });
+});
diff --git a/src/services/offlineApi.ts b/src/services/offlineApi.ts
index fc0df875..0bdd9700 100644
--- a/src/services/offlineApi.ts
+++ b/src/services/offlineApi.ts
@@ -1,4 +1,5 @@
 import { apiClient } from '@/lib/api';
+import { VersionVector } from '@/lib/conflict/types';
 
 export interface OfflineProgressPayload {
   courseId: string;
@@ -7,6 +8,15 @@ export interface OfflineProgressPayload {
   completed: boolean;
   updatedAt: string;
   version?: number;
+  /**
+   * Client-generated idempotency key. The server is expected to dedupe on it so
+   * duplicate delivery of the same offline operation applies exactly once.
+   */
+  operationId?: string;
+  /** Replica/device that produced this change (deterministic conflict detection). */
+  updatedBy?: string;
+  logicalClock?: number;
+  versionVector?: VersionVector;
 }
 
 export interface OfflineProgressSyncResponse {
@@ -15,6 +25,11 @@ export interface OfflineProgressSyncResponse {
   data: OfflineProgressPayload & {
     lessonId: string;
   };
+  /**
+   * Set by the server when the operation was already applied (deduplicated).
+   * The client can then safely drop the queued operation without re-applying.
+   */
+  deduplicated?: boolean;
 }
 
 export const offlineApi = {
diff --git a/src/services/offlineSync.ts b/src/services/offlineSync.ts
index b78b0ce1..c6cbe46e 100644
--- a/src/services/offlineSync.ts
+++ b/src/services/offlineSync.ts
@@ -1,17 +1,29 @@
 'use client';
 
-import { openDB, IDBPDatabase } from 'idb';
+import { openDB, IDBPDatabase, IDBPObjectStore } from 'idb';
 import {
   ConflictRecord,
   ResolutionStrategy,
+  VersionVector,
   detectConflict,
   resolveConflict,
   createConflictRecord,
+  mergeVersionVectors,
 } from '@/lib/conflict/resolver';
+import {
+  SYNC_BATCH_SIZE,
+  SYNC_MAX_RETRY_ATTEMPTS,
+  SYNC_BACKOFF_BASE_MS,
+  SYNC_BACKOFF_CAP_MS,
+  SYNC_RETENTION_MS,
+  DEAD_LETTER_RETENTION_MS,
+} from '@/constants/app.constants';
 import { offlineApi } from './offlineApi';
 
 export type SyncItemType = 'course_progress';
 
+export type SyncItemStatus = 'pending' | 'conflicted' | 'dead' | 'acked';
+
 export interface OfflineAssetRecord {
   id: string;
   courseId: string;
@@ -56,35 +68,80 @@ export interface OfflineProgressRecord {
   synced: boolean;
   syncedAt?: string;
   version?: number;
+  /** Replica/device that produced the last local change. */
+  updatedBy?: string;
+  /** Lamport logical clock — monotonic, immune to wall-clock drift. */
+  logicalClock?: number;
+  /** Per-record version vector for deterministic conflict detection. */
+  versionVector?: VersionVector;
 }
 
 export interface SyncQueueItem {
+  /** Internal queue id. */
   id: string;
+  /** Client-generated idempotency key sent to the server for dedupe. */
+  operationId: string;
+  /** Monotonic sequence number used by the resumable drain cursor. */
+  seq: number;
   type: SyncItemType;
   entityKey: string;
   data: any;
   timestamp: string;
   version: number;
+  versionVector: VersionVector;
+  updatedBy: string;
+  status: SyncItemStatus;
+  /** Delivery attempts so far (persisted across restarts). */
+  attempts: number;
+  /** Lifetime delivery cap before the operation is dead-lettered. */
+  maxAttempts: number;
+  lastError?: string;
+}
+
+export interface DeadLetterRecord extends SyncQueueItem {
+  failedAt: string;
+  lastError: string;
 }
 
 export type SyncConflict = ConflictRecord<any>;
 
+/** UI-facing sync status derived from the offline stores. */
+export interface SyncStatus {
+  isSyncing: boolean;
+  pending: number;
+  conflicted: number;
+  resolved: number;
+  deadLetter: number;
+  lastSyncTime: string | null;
+}
+
 export interface SyncResult {
   success: boolean;
   syncedItems: number;
   conflicts: SyncConflict[];
   errors: string[];
   lastSyncTime: string;
+  /** Number of operations resolved automatically (merge/local/remote). */
+  resolved?: number;
+  /** Number of operations moved to the dead-letter queue. */
+  deadLettered?: number;
+  /** Drain cursor position after this run (for observability). */
+  cursor?: number;
 }
 
 export interface SyncOptions {
   forceSync?: boolean;
   resolveConflicts?: 'auto' | ResolutionStrategy;
   retryAttempts?: number;
+  /** Lifetime delivery cap per operation (defaults to SYNC_MAX_RETRY_ATTEMPTS). */
+  maxRetryAttempts?: number;
+  batchSize?: number;
+  backoffBaseMs?: number;
+  backoffCapMs?: number;
 }
 
 export const OFFLINE_DB_NAME = 'teachlink-offline';
-export const OFFLINE_DB_VERSION = 2;
+export const OFFLINE_DB_VERSION = 3;
 
 const ensureBrowser = () => {
   if (typeof window === 'undefined') {
@@ -101,13 +158,53 @@ const createEntityKey = (_type: SyncItemType, data: unknown) => {
   throw new Error('Invalid data structure for entity key');
 };
 
+const generateId = (prefix: string): string =>
+  `${prefix}-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+
+const generateOperationId = (type: SyncItemType): string =>
+  `op-${type}-${Date.now()}-${Math.random().toString(36).slice(2, 12)}`;
+
+const delay = (ms: number): Promise<void> => new Promise((resolve) => setTimeout(resolve, ms));
+
+/**
+ * Backfills legacy v2 queue records with the fields required for idempotent,
+ * cursor-based draining (operationId, seq, status, attempts, version vector).
+ */
+async function migrateLegacyQueueItems(queueStore: any): Promise<void> {
+  const replicaId = `replica-${Math.random().toString(36).slice(2, 10)}`;
+  let seq = 1;
+  let cursor = await queueStore.openCursor();
+  while (cursor) {
+    const record = cursor.value as Partial<SyncQueueItem>;
+    await cursor.update({
+      ...record,
+      operationId: record.operationId ?? record.id ?? generateOperationId('course_progress'),
+      seq: record.seq ?? seq++,
+      status: record.status ?? 'pending',
+      attempts: record.attempts ?? 0,
+      maxAttempts: record.maxAttempts ?? SYNC_MAX_RETRY_ATTEMPTS,
+      updatedBy: record.updatedBy ?? replicaId,
+      versionVector:
+        record.versionVector ??
+        (record.version ? { [replicaId]: record.version } : { [replicaId]: 1 }),
+    });
+    cursor = await cursor.continue();
+  }
+}
+
+/** Reads the persisted cursor / seq / replica metadata. */
+const META_CURSOR = 'syncCursor';
+const META_LAST_SEQ = 'lastSeq';
+const META_REPLICA_ID = 'replicaId';
+
 export class OfflineStorage {
   private db: IDBPDatabase | null = null;
 
   async init(): Promise<void> {
     ensureBrowser();
     this.db = await openDB(OFFLINE_DB_NAME, OFFLINE_DB_VERSION, {
-      upgrade: (db) => {
+      upgrade: async (db, _oldVersion, _newVersion, transaction) => {
+        // NOTE: object stores must be created synchronously, before any await.
         if (!db.objectStoreNames.contains('courses')) {
           const courseStore = db.createObjectStore('courses', { keyPath: 'id' });
           courseStore.createIndex('downloadedAt', 'downloadedAt', { unique: false });
@@ -133,12 +230,38 @@ export class OfflineStorage {
           syncStore.createIndex('type', 'type', { unique: false });
           syncStore.createIndex('timestamp', 'timestamp', { unique: false });
           syncStore.createIndex('entityKey', 'entityKey', { unique: false });
+          syncStore.createIndex('seq', 'seq', { unique: true });
+          syncStore.createIndex('status', 'status', { unique: false });
         }
 
         if (!db.objectStoreNames.contains('conflicts')) {
           const conflictStore = db.createObjectStore('conflicts', { keyPath: 'id' });
           conflictStore.createIndex('resolved', 'resolved', { unique: false });
           conflictStore.createIndex('entityKey', 'entityKey', { unique: false });
+          conflictStore.createIndex('state', 'state', { unique: false });
+        }
+
+        // Metadata: drain cursor, sequence counter, replica id, ack timestamps.
+        if (!db.objectStoreNames.contains('syncMeta')) {
+          db.createObjectStore('syncMeta', { keyPath: 'key' });
+        }
+
+        // Dedupe map: operationId -> ack. Makes replay idempotent.
+        if (!db.objectStoreNames.contains('ackedOps')) {
+          const ackedStore = db.createObjectStore('ackedOps', { keyPath: 'operationId' });
+          ackedStore.createIndex('ackedAt', 'ackedAt', { unique: false });
+        }
+
+        // Dead-letter queue for operations that exhausted their retries.
+        if (!db.objectStoreNames.contains('deadLetter')) {
+          const deadStore = db.createObjectStore('deadLetter', { keyPath: 'id' });
+          deadStore.createIndex('failedAt', 'failedAt', { unique: false });
+        }
+
+        // Migrate legacy v2 queue items so they gain idempotency fields and a
+        // sequence number; without this the resumable cursor would skip them.
+        if (_oldVersion < 3 && db.objectStoreNames.contains('syncQueue')) {
+          await migrateLegacyQueueItems(transaction.objectStore('syncQueue'));
         }
       },
     });
@@ -151,6 +274,16 @@ export class OfflineStorage {
     return this.db;
   }
 
+  /** Stable per-device replica id used for version vectors and conflict detection. */
+  async getReplicaId(): Promise<string> {
+    const db = this.getDb();
+    const existing = await db.get('syncMeta', META_REPLICA_ID);
+    if (existing) return existing.value as string;
+    const replicaId = `replica-${Math.random().toString(36).slice(2, 10)}`;
+    await db.put('syncMeta', { key: META_REPLICA_ID, value: replicaId });
+    return replicaId;
+  }
+
   async saveCourse(course: OfflineCourseRecord): Promise<void> {
     const db = this.getDb();
     await db.put('courses', course);
@@ -249,6 +382,9 @@ export class OfflineStorage {
     await db.clear('progress');
     await db.clear('syncQueue');
     await db.clear('conflicts');
+    await db.clear('syncMeta');
+    await db.clear('ackedOps');
+    await db.clear('deadLetter');
   }
 
   async getStorageUsage(): Promise<{ used: number; total: number; percentage: number }> {
@@ -257,6 +393,7 @@ export class OfflineStorage {
     const assets = await db.getAll('assets');
     const progress = await db.getAll('progress');
     const syncQueue = await db.getAll('syncQueue');
+    const deadLetter = await db.getAll('deadLetter');
 
     const used =
       courses.reduce(
@@ -268,7 +405,8 @@ export class OfflineStorage {
         0,
       ) +
       progress.length * 1024 +
-      syncQueue.length * 512;
+      syncQueue.length * 512 +
+      deadLetter.length * 512;
 
     if ('storage' in navigator && 'estimate' in navigator.storage) {
       const estimate = await navigator.storage.estimate();
@@ -281,6 +419,22 @@ export class OfflineStorage {
   }
 }
 
+interface BatchOutcome {
+  success: boolean;
+  syncedItems: number;
+  conflicts: SyncConflict[];
+  errors: string[];
+  deadLettered: number;
+}
+
+interface ItemAttempt {
+  item: SyncQueueItem;
+  ok: boolean;
+  acked?: boolean;
+  dead?: boolean;
+  response?: Awaited<ReturnType<typeof offlineApi.syncLessonProgress>>;
+}
+
 export class OfflineSyncService {
   private readonly storage: OfflineStorage;
   private isSyncing = false;
@@ -293,14 +447,34 @@ export class OfflineSyncService {
     return this.storage.getDb();
   }
 
+  // -------------------------------------------------------------------------
+  // Queue management
+  // -------------------------------------------------------------------------
+
   async enqueue(type: SyncItemType, data: any): Promise<SyncQueueItem> {
+    const replicaId = await this.storage.getReplicaId();
+    const seq = await this.nextSeq();
+    const operationId = generateOperationId(type);
+
     const item: SyncQueueItem = {
-      id: `${type}-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+      id: generateId('sync'),
+      operationId,
+      seq,
       type,
       entityKey: createEntityKey(type, data),
-      data,
+      data: {
+        ...data,
+        operationId,
+        updatedBy: data.updatedBy ?? replicaId,
+      },
       timestamp: new Date().toISOString(),
-      version: 1,
+      version: data.version ?? 1,
+      versionVector:
+        (data.versionVector as VersionVector | undefined) ?? { [replicaId]: 1 },
+      updatedBy: replicaId,
+      status: 'pending',
+      attempts: 0,
+      maxAttempts: SYNC_MAX_RETRY_ATTEMPTS,
     };
 
     await this.db.put('syncQueue', item);
@@ -334,13 +508,52 @@ export class OfflineSyncService {
     await this.db.clear('syncQueue');
   }
 
+  // -------------------------------------------------------------------------
+  // Dead-letter queue
+  // -------------------------------------------------------------------------
+
+  async getDeadLetter(): Promise<DeadLetterRecord[]> {
+    return await this.db.getAll('deadLetter');
+  }
+
+  async getDeadLetterCount(): Promise<number> {
+    return (await this.db.getAll('deadLetter')).length;
+  }
+
+  /** Re-enqueue a dead-lettered operation for another sync attempt. */
+  async retryDeadLetter(id: string): Promise<boolean> {
+    const record = await this.db.get('deadLetter', id);
+    if (!record) return false;
+
+    const { failedAt: _failedAt, lastError: _lastError, ...rest } = record;
+    const tx = this.db.transaction(['deadLetter', 'syncQueue', 'syncMeta'], 'readwrite');
+    const metaStore = tx.objectStore('syncMeta');
+    const meta = await metaStore.get(META_LAST_SEQ);
+    const next = (typeof meta?.value === 'number' ? meta.value : 0) + 1;
+    await metaStore.put({ key: META_LAST_SEQ, value: next });
+    await tx.objectStore('deadLetter').delete(id);
+    // Fresh sequence number so the retry sits after the drain cursor.
+    await tx.objectStore('syncQueue').put({
+      ...rest,
+      status: 'pending',
+      attempts: 0,
+      seq: next,
+    });
+    await tx.done;
+    return true;
+  }
+
+  // -------------------------------------------------------------------------
+  // Conflicts
+  // -------------------------------------------------------------------------
+
   private async addConflict(conflict: SyncConflict): Promise<void> {
     await this.db.put('conflicts', conflict);
   }
 
   async getPendingConflicts(): Promise<SyncConflict[]> {
-    const index = this.db.transaction('conflicts').objectStore('conflicts').index('resolved');
-    return await index.getAll(IDBKeyRange.only(false));
+    const conflicts = await this.db.getAll('conflicts');
+    return conflicts.filter((conflict) => !conflict.resolved);
   }
 
   async resolveConflict(
@@ -354,12 +567,14 @@ export class OfflineSyncService {
     const resolvedData =
       strategy === 'manual' && manualData
         ? manualData
-        : resolveConflict(conflict.localData, conflict.remoteData, strategy);
+        : resolveConflict(conflict.localData, conflict.remoteData, strategy, conflict.entityType);
 
+    const replicaId = await this.storage.getReplicaId();
     const resolvedConflict: SyncConflict = {
       ...conflict,
       strategy,
       resolved: true,
+      state: 'resolved',
       history: [
         ...conflict.history,
         {
@@ -370,19 +585,157 @@ export class OfflineSyncService {
       ],
     };
 
-    await this.db.put('conflicts', resolvedConflict);
+    const tx = this.db.transaction(['conflicts', 'progress', 'syncQueue', 'ackedOps'], 'readwrite');
+    await tx.objectStore('conflicts').put(resolvedConflict);
 
     const [courseId, moduleId] = conflict.entityKey.split(':');
-    await this.storage.saveProgress({
+    await tx.objectStore('progress').put({
       courseId,
       moduleId,
       ...resolvedData,
+      versionVector: mergeVersionVectors(
+        (resolvedData?.versionVector as VersionVector | undefined) ?? {},
+        { [replicaId]: 1 },
+      ),
+      updatedBy: replicaId,
       synced: true,
       syncedAt: new Date().toISOString(),
     });
-    await this.removeQueueItemsForEntity(conflict.entityKey);
+
+    // Drop any queued operations for this entity and ack them so they are never
+    // replayed after a manual resolution.
+    const queueIndex = tx.objectStore('syncQueue').index('entityKey');
+    const queued = await queueIndex.getAll(conflict.entityKey);
+    for (const item of queued) {
+      await tx.objectStore('ackedOps').put({
+        operationId: item.operationId,
+        entityKey: item.entityKey,
+        ackedAt: new Date().toISOString(),
+      });
+      await tx.objectStore('syncQueue').delete(item.id);
+    }
+    await tx.done;
+  }
+
+  // -------------------------------------------------------------------------
+  // Sync status (UI-facing deterministic conflict state)
+  // -------------------------------------------------------------------------
+
+  async getSyncStatus(): Promise<SyncStatus> {
+    const [queue, conflicts, deadLetter] = await Promise.all([
+      this.db.getAll('syncQueue'),
+      this.db.getAll('conflicts'),
+      this.db.getAll('deadLetter'),
+    ]);
+
+    const pending = queue.filter((item) => item.status === 'pending').length;
+    const conflicted = conflicts.filter((c) => c.state === 'conflicted').length;
+    const resolved = conflicts.filter((c) => c.state === 'resolved').length;
+    const lastSyncMeta = await this.db.get('syncMeta', 'lastSyncTime');
+
+    return {
+      isSyncing: this.isSyncing,
+      pending,
+      conflicted,
+      resolved,
+      deadLetter: deadLetter.length,
+      lastSyncTime: (lastSyncMeta?.value as string | null) ?? null,
+    };
+  }
+
+  // -------------------------------------------------------------------------
+  // Resumable cursor + sequence numbers
+  // -------------------------------------------------------------------------
+
+  private async getCursor(): Promise<number> {
+    const meta = await this.db.get('syncMeta', META_CURSOR);
+    return typeof meta?.value === 'number' ? meta.value : 0;
+  }
+
+  private async advanceCursor(seq: number): Promise<void> {
+    const tx = this.db.transaction('syncMeta', 'readwrite');
+    await tx.objectStore('syncMeta').put({ key: META_CURSOR, value: seq });
+    await tx.objectStore('syncMeta').put({
+      key: 'lastSyncTime',
+      value: new Date().toISOString(),
+    });
+    await tx.done;
+  }
+
+  private async nextSeq(): Promise<number> {
+    const tx = this.db.transaction('syncMeta', 'readwrite');
+    const store = tx.objectStore('syncMeta');
+    const meta = await store.get(META_LAST_SEQ);
+    const next = (typeof meta?.value === 'number' ? meta.value : 0) + 1;
+    await store.put({ key: META_LAST_SEQ, value: next });
+    await tx.done;
+    return next;
+  }
+
+  /**
+   * Loads the next batch of pending operations strictly after the cursor.
+   * Because the cursor is persisted, a drain interrupted by a crash/restart
+   * resumes exactly where it left off instead of re-processing history.
+   */
+  private async loadBatch(cursor: number, batchSize: number): Promise<SyncQueueItem[]> {
+    const queue = await this.db.getAll('syncQueue');
+    return queue
+      .filter((item) => item.status === 'pending' && item.seq > cursor)
+      .sort((a, b) => a.seq - b.seq)
+      .slice(0, batchSize);
+  }
+
+  // -------------------------------------------------------------------------
+  // Idempotency helpers
+  // -------------------------------------------------------------------------
+
+  private async isAcked(operationId: string): Promise<boolean> {
+    return Boolean(await this.db.get('ackedOps', operationId));
+  }
+
+  // -------------------------------------------------------------------------
+  // Retention / GC for acked + dead-lettered records
+  // -------------------------------------------------------------------------
+
+  /** Removes acked ops and dead-letter records older than their retention windows. */
+  async gcAckedRecords(): Promise<{ acked: number; deadLetter: number }> {
+    const now = Date.now();
+    const tx = this.db.transaction(['ackedOps', 'deadLetter'], 'readwrite');
+    const ackedStore = tx.objectStore('ackedOps');
+    const deadStore = tx.objectStore('deadLetter');
+
+    const ackedIndex = ackedStore.index('ackedAt');
+    let ackedCursor = await ackedIndex.openCursor();
+    let ackedRemoved = 0;
+    while (ackedCursor) {
+      const record = ackedCursor.value as { ackedAt: string };
+      if (now - new Date(record.ackedAt).getTime() > SYNC_RETENTION_MS) {
+        await ackedCursor.delete();
+        ackedRemoved += 1;
+      }
+      ackedCursor = await ackedCursor.continue();
+    }
+
+    const deadIndex = deadStore.index('failedAt');
+    let deadCursor = await deadIndex.openCursor();
+    let deadRemoved = 0;
+    while (deadCursor) {
+      const record = deadCursor.value as { failedAt: string };
+      if (now - new Date(record.failedAt).getTime() > DEAD_LETTER_RETENTION_MS) {
+        await deadCursor.delete();
+        deadRemoved += 1;
+      }
+      deadCursor = await deadCursor.continue();
+    }
+
+    await tx.done;
+    return { acked: ackedRemoved, deadLetter: deadRemoved };
   }
 
+  // -------------------------------------------------------------------------
+  // Deterministic, idempotent, transactional sync
+  // -------------------------------------------------------------------------
+
   async syncData(options: SyncOptions = {}): Promise<SyncResult> {
     if (this.isSyncing && !options.forceSync) {
       throw new Error('Sync already in progress');
@@ -396,29 +749,39 @@ export class OfflineSyncService {
       conflicts: [],
       errors: [],
       lastSyncTime: new Date().toISOString(),
+      resolved: 0,
+      deadLettered: 0,
+      cursor: 0,
     };
 
     try {
-      const queue = await this.getQueue();
-      if (queue.length === 0) {
-        result.success = true;
-        return result;
-      }
+      await this.gcAckedRecords();
+
+      const batchSize = options.batchSize ?? SYNC_BATCH_SIZE;
+      let cursor = await this.getCursor();
+
+      for (;;) {
+        const batch = await this.loadBatch(cursor, batchSize);
+        if (batch.length === 0) break;
+
+        const outcome = await this.drainBatch(batch, options);
+        result.syncedItems += outcome.syncedItems;
+        result.conflicts.push(...outcome.conflicts);
+        result.errors.push(...outcome.errors);
+        result.deadLettered = (result.deadLettered ?? 0) + outcome.deadLettered;
+        result.resolved = (result.resolved ?? 0) + outcome.syncedItems;
 
-      const grouped = queue.reduce<Record<string, SyncQueueItem[]>>((acc, item) => {
-        acc[item.type] = acc[item.type] || [];
-        acc[item.type].push(item);
-        return acc;
-      }, {});
-
-      for (const items of Object.values(grouped)) {
-        const syncResult = await this.syncProgressItems(items, options);
-        result.syncedItems += syncResult.syncedItems;
-        result.conflicts.push(...syncResult.conflicts);
-        result.errors.push(...syncResult.errors);
+        if (!outcome.success) break;
+
+        // Commit point: the whole batch drained, so the cursor can advance.
+        const lastSeq = batch[batch.length - 1].seq;
+        cursor = lastSeq;
+        await this.advanceCursor(lastSeq);
+        result.cursor = cursor;
       }
 
       result.success = result.errors.length === 0;
+      result.lastSyncTime = new Date().toISOString();
     } catch (error) {
       result.errors.push(`Sync failed: ${String(error)}`);
     } finally {
@@ -428,101 +791,220 @@ export class OfflineSyncService {
     return result;
   }
 
-  private async syncProgressItems(
-    items: SyncQueueItem[],
-    options: SyncOptions,
-  ): Promise<{ syncedItems: number; conflicts: SyncConflict[]; errors: string[] }> {
-    const groupedByEntity = items.reduce<Record<string, SyncQueueItem[]>>((acc, item) => {
-      if (!acc[item.entityKey]) acc[item.entityKey] = [];
-      acc[item.entityKey].push(item);
-      return acc;
-    }, {});
+  /**
+   * Drains a single batch all-or-nothing.
+   *
+   * - Every operation is attempted with capped exponential backoff.
+   * - Operations that exhaust their lifetime retry cap are dead-lettered and
+   *   do not block the batch.
+   * - If a non-exhausted operation still fails, the ENTIRE batch is rolled
+   *   back: no queue deletions, no acks, no progress-store writes. The cursor
+   *   stays put, so the next drain (after restart or connectivity) resumes
+   *   from exactly this batch.
+   */
+  private async drainBatch(batch: SyncQueueItem[], options: SyncOptions): Promise<BatchOutcome> {
+    const outcomes: BatchOutcome = {
+      success: false,
+      syncedItems: 0,
+      conflicts: [],
+      errors: [],
+      deadLettered: 0,
+    };
+
+    const attempts: ItemAttempt[] = [];
 
-    const conflicts: SyncConflict[] = [];
-    const errors: string[] = [];
-    let syncedItems = 0;
+    for (const item of batch) {
+      // Idempotent replay: an already-acked operation is never re-sent.
+      if (await this.isAcked(item.operationId)) {
+        attempts.push({ item, ok: true, acked: true });
+        continue;
+      }
+
+      const attempt = await this.attemptWithBackoff(item, options);
+
+      if (attempt.ok) {
+        attempts.push(attempt);
+        continue;
+      }
 
-    for (const [entityKey, entityItems] of Object.entries(groupedByEntity)) {
-      const candidate = this.pickBestProgressItem(entityItems);
-      if (!candidate) continue;
+      // Persist the incremented attempt count for the retry lifecycle.
+      await this.updateItemAttempts(item, attempt.attempts ?? item.attempts, attempt.error);
 
-      const [courseId, moduleId] = entityKey.split(':');
-      const existing = await this.storage.getProgress(courseId, moduleId);
+      const retryCap = options.maxRetryAttempts ?? item.maxAttempts;
+      if ((attempt.attempts ?? item.attempts) >= retryCap) {
+        // Exhausted: move to the dead-letter queue and keep draining the batch.
+        await this.deadLetter(item, attempt.error);
+        outcomes.deadLettered += 1;
+        continue;
+      }
+
+      // Transient failure that has not exhausted retries: roll the whole batch
+      // back and stop. Nothing above is committed.
+      outcomes.errors.push(
+        `Failed to sync operation ${item.operationId} (${item.entityKey}): ${attempt.error}`,
+      );
+      return outcomes;
+    }
 
+    // All-or-nothing commit inside a single IndexedDB transaction.
+    await this.commitBatch(attempts, options, outcomes);
+    outcomes.success = true;
+    return outcomes;
+  }
+
+  /**
+   * Attempts a single operation with capped exponential backoff between
+   * retries (default: SYNC_MAX_RETRY_ATTEMPTS attempts per drain).
+   */
+  private async attemptWithBackoff(
+    item: SyncQueueItem,
+    options: SyncOptions,
+  ): Promise<ItemAttempt & { attempts: number; error?: string }> {
+    const retryAttempts = options.retryAttempts ?? 2;
+    const baseMs = options.backoffBaseMs ?? SYNC_BACKOFF_BASE_MS;
+    const capMs = options.backoffCapMs ?? SYNC_BACKOFF_CAP_MS;
+
+    let attempts = item.attempts;
+    let lastError: string | undefined;
+
+    for (let i = 0; i < retryAttempts; i++) {
+      attempts += 1;
       try {
-        const response = await offlineApi.syncLessonProgress(candidate.data);
-        const remoteData = response?.data ?? candidate.data;
+        const response = await offlineApi.syncLessonProgress(item.data);
+        return { item, ok: true, response, attempts };
+      } catch (error) {
+        lastError = error instanceof Error ? error.message : String(error);
+        if (i < retryAttempts - 1) {
+          const backoff = Math.min(capMs, baseMs * Math.pow(2, i));
+          await delay(backoff);
+        }
+      }
+    }
 
-        const isConflicted =
-          existing?.synced && detectConflict(candidate.data, remoteData) && response.success;
+    return { item, ok: false, error: lastError, attempts };
+  }
+
+  private async updateItemAttempts(
+    item: SyncQueueItem,
+    attempts: number,
+    error?: string,
+  ): Promise<void> {
+    const updated: SyncQueueItem = {
+      ...item,
+      attempts,
+      status: 'pending',
+    };
+    if (error !== undefined) {
+      updated.lastError = error;
+    }
+    await this.db.put('syncQueue', updated);
+  }
 
-        if (isConflicted) {
-          const conflict = createConflictRecord(
-            candidate.type,
-            entityKey,
-            candidate.data,
+  private async deadLetter(item: SyncQueueItem, error?: string): Promise<void> {
+    const tx = this.db.transaction(['deadLetter', 'syncQueue'], 'readwrite');
+    await tx.objectStore('deadLetter').put({
+      ...item,
+      status: 'dead',
+      failedAt: new Date().toISOString(),
+      lastError: error ?? item.lastError ?? 'Max retries exceeded',
+    });
+    await tx.objectStore('syncQueue').delete(item.id);
+    await tx.done;
+  }
+
+  /**
+   * Commits a fully-successful batch atomically: acks are recorded, queue
+   * items removed, progress reconciled with deterministic conflict handling.
+   */
+  private async commitBatch(
+    attempts: ItemAttempt[],
+    options: SyncOptions,
+    outcome: BatchOutcome,
+  ): Promise<void> {
+    const db = this.db;
+    const tx = db.transaction(
+      ['syncQueue', 'ackedOps', 'progress', 'conflicts'],
+      'readwrite',
+    );
+    const queueStore = tx.objectStore('syncQueue');
+    const ackStore = tx.objectStore('ackedOps');
+    const progressStore = tx.objectStore('progress');
+    const conflictStore = tx.objectStore('conflicts');
+    const now = new Date().toISOString();
+
+    for (const attempt of attempts) {
+      const { item } = attempt;
+
+      await ackStore.put({
+        operationId: item.operationId,
+        entityKey: item.entityKey,
+        ackedAt: now,
+      });
+
+      if (attempt.acked) {
+        // Already applied server-side; just drop the stale queue entry.
+        await queueStore.delete(item.id);
+        continue;
+      }
+
+      const remoteData = attempt.response?.data ?? item.data;
+      const [courseId, moduleId] = item.entityKey.split(':');
+      const existing = await progressStore.get([courseId, moduleId]);
+
+      const conflicted =
+        existing && detectConflict(existing, remoteData) && attempt.response?.success !== false;
+
+      if (conflicted) {
+        const strategy = this.resolveConflictStrategy(
+          {
+            entityType: item.type,
+            entityKey: item.entityKey,
+            localData: existing,
             remoteData,
-          );
-          const strategy = this.resolveConflictStrategy(conflict, options);
-
-          if (strategy !== 'manual') {
-            const resolvedData = resolveConflict(candidate.data, remoteData, strategy);
-            conflict.strategy = strategy;
-            conflict.resolved = true;
-            conflict.history.push({
-              timestamp: new Date().toISOString(),
-              action: 'AUTO_RESOLVED',
-              details: `Automatically resolved using ${strategy} strategy`,
-            });
-
-            await this.storage.saveProgress({
-              courseId,
-              moduleId,
-              ...resolvedData,
-              synced: true,
-              syncedAt: new Date().toISOString(),
-            });
-            await this.removeQueueItemsForEntity(entityKey);
-            syncedItems += entityItems.length;
-          } else {
-            await this.addConflict(conflict);
-            conflicts.push(conflict);
-          }
+          } as SyncConflict,
+          options,
+        );
+
+        if (strategy === 'manual') {
+          const conflict = createConflictRecord(item.type, item.entityKey, existing, remoteData);
+          await conflictStore.put(conflict);
+          await queueStore.delete(item.id);
+          outcome.conflicts.push(conflict);
         } else {
-          await this.storage.saveProgress({
+          const resolved = resolveConflict(existing, remoteData, strategy, item.type);
+          await progressStore.put({
             courseId,
             moduleId,
-            progress: remoteData.progress,
-            completed: remoteData.completed,
-            updatedAt: remoteData.updatedAt,
-            version: remoteData.version,
+            ...resolved,
             synced: true,
-            syncedAt: new Date().toISOString(),
+            syncedAt: now,
           });
-          await this.removeQueueItemsForEntity(entityKey);
-          syncedItems += entityItems.length;
+          await queueStore.delete(item.id);
+          outcome.syncedItems += 1;
         }
-      } catch (error) {
-        errors.push(`Failed to sync progress for ${entityKey}: ${String(error)}`);
+      } else {
+        await progressStore.put({
+          courseId,
+          moduleId,
+          progress: remoteData.progress,
+          completed: remoteData.completed,
+          updatedAt: remoteData.updatedAt,
+          version: remoteData.version,
+          logicalClock: remoteData.logicalClock,
+          updatedBy: remoteData.updatedBy,
+          versionVector: mergeVersionVectors(
+            (remoteData.versionVector as VersionVector | undefined) ?? {},
+            (existing?.versionVector as VersionVector | undefined) ?? {},
+          ),
+          synced: true,
+          syncedAt: now,
+        });
+        await queueStore.delete(item.id);
+        outcome.syncedItems += 1;
       }
     }
 
-    return { syncedItems, conflicts, errors };
-  }
-
-  private pickBestProgressItem(items: SyncQueueItem[]): SyncQueueItem | null {
-    if (items.length === 0) return null;
-
-    return items.reduce((best, current) => {
-      const bestUpdated = new Date(best.data.updatedAt).getTime();
-      const currentUpdated = new Date(current.data.updatedAt).getTime();
-      if (currentUpdated > bestUpdated) return current;
-      if (currentUpdated === bestUpdated && current.data.progress > best.data.progress) {
-        return current;
-      }
-      if (current.data.completed && !best.data.completed) return current;
-      return best;
-    });
+    await tx.done;
   }
 
   private resolveConflictStrategy(
@@ -541,7 +1023,7 @@ export class OfflineSyncService {
       return 'manual';
     }
 
-    // Default auto strategy: intelligently merge progress payloads
+    // Default auto strategy: deterministically merge progress payloads.
     return 'merge';
   }
 }
diff --git a/src/store/persistenceLayer.ts b/src/store/persistenceLayer.ts
index 552a487f..9b66fd8d 100644
--- a/src/store/persistenceLayer.ts
+++ b/src/store/persistenceLayer.ts
@@ -54,4 +54,24 @@ export const persistenceLayer = {
     const db = await openDB(DB_NAME, 1);
     await db.delete(STORE_NAME, name);
   },
+
+  /**
+   * Loads a JSON value stored under `name` (returns null when absent).
+   */
+  async getJSON<T>(name: string): Promise<T | null> {
+    const raw = await this.getItem(name);
+    if (!raw) return null;
+    try {
+      return JSON.parse(raw) as T;
+    } catch {
+      return null;
+    }
+  },
+
+  /**
+   * Persists a JSON value under `name`.
+   */
+  async setJSON<T>(name: string, value: T): Promise<void> {
+    await this.setItem(name, JSON.stringify(value));
+  },
 };
diff --git a/src/store/stateManager.ts b/src/store/stateManager.ts
index 33c5779b..e1193263 100644
--- a/src/store/stateManager.ts
+++ b/src/store/stateManager.ts
@@ -16,10 +16,14 @@ interface UserState {
   };
 }
 
+/** UI-facing offline sync status reconciled after each drain. */
+export type SyncStatusState = 'idle' | 'syncing' | 'pending' | 'conflicted' | 'resolved';
+
 interface AppState {
   isSidebarOpen: boolean;
   offlineMode: boolean;
   lastSynced: number | null;
+  syncStatus: SyncStatusState;
 }
 
 interface StoreState {
@@ -59,6 +63,7 @@ export const useStore = create<StoreState>()(
           isSidebarOpen: true,
           offlineMode: false,
           lastSynced: null,
+          syncStatus: 'idle' as SyncStatusState,
         },
 
         setUser: (user: Partial<UserState>) =>
diff --git a/src/store/synchronizationEngine.ts b/src/store/synchronizationEngine.ts
index facfea3f..327933af 100644
--- a/src/store/synchronizationEngine.ts
+++ b/src/store/synchronizationEngine.ts
@@ -1,11 +1,15 @@
 import { useStore } from './stateManager';
 import { createLogger } from '@/lib/logging';
+import { persistenceLayer } from './persistenceLayer';
+import { SyncStatusState } from './stateManager';
 import { onAnyReconnect } from '@/lib/realtime/connectionSupervisor';
 
 const logger = createLogger('synchronization-engine');
 
 const CHANNEL_NAME = 'teachlink_state_sync';
 
+const SYNC_STATE_KEY = 'offline_sync_status';
+
 /** Shallow equality: primitives compared by value, objects by reference-per-key. */
 function shallowEqual(a: any, b: any): boolean {
   if (a === b) return true;
@@ -15,7 +19,42 @@ function shallowEqual(a: any, b: any): boolean {
   return keysA.every(k => a[k] === b[k]);
 }
 
-const SYNC_KEYS = ['user', 'preferences', 'offlineMode', 'lastSynced'] as const;
+/** The slice of store state that is safe to broadcast across tabs. */
+function syncedStateSlice(state: any) {
+  return {
+    user: state.user,
+    app: {
+      offlineMode: state.app?.offlineMode,
+      lastSynced: state.app?.lastSynced,
+      syncStatus: state.app?.syncStatus,
+    },
+  };
+}
+
+/** True when any of the persisted keys that matter for cross-tab sync changed. */
+function hasSyncedKeyChanged(state: any, prevState: any): boolean {
+  if (!shallowEqual(state.user, prevState.user)) return true;
+  if (state.app?.offlineMode !== prevState.app?.offlineMode) return true;
+  if (state.app?.lastSynced !== prevState.app?.lastSynced) return true;
+  if (state.app?.syncStatus !== prevState.app?.syncStatus) return true;
+  return false;
+}
+
+/** Result of a batch drain, reconciled into the persisted store. */
+export interface DrainResult {
+  success: boolean;
+  syncedItems: number;
+  conflicts: number;
+  lastSyncTime: string;
+}
+
+/** Derives the UI-facing sync status from a drain result + pending counts. */
+function deriveSyncStatus(result: DrainResult, pending: number): SyncStatusState {
+  if (!result.success) return 'pending';
+  if (result.conflicts > 0) return 'conflicted';
+  if (pending > 0) return 'pending';
+  return result.syncedItems > 0 ? 'resolved' : 'idle';
+}
 
 /**
  * Synchronization engine for keeping state in sync across multiple browser tabs.
@@ -58,9 +97,7 @@ export class SynchronizationEngine {
     useStore.subscribe((state: any, prevState: any) => {
       if (this.isProcessingSync) return;
 
-      const hasChanged = SYNC_KEYS.some(key => !shallowEqual(state[key], prevState[key]));
-
-      if (hasChanged) {
+      if (hasSyncedKeyChanged(state, prevState)) {
         this.broadcastState(state);
       }
     });
@@ -70,19 +107,56 @@ export class SynchronizationEngine {
     if (!this.channel) return;
 
     logger.debug('[SyncEngine] Broadcasting state update to other tabs');
-    // Only send the synced slice
-    const syncedState = SYNC_KEYS.reduce((acc, key) => {
-      acc[key] = state[key as keyof typeof state];
-      return acc;
-    }, {} as any);
-
-    console.log('[SyncEngine] Broadcasting synced state slice');
     this.channel.postMessage({
       type: 'STATE_UPDATE',
-      payload: syncedState,
+      payload: syncedStateSlice(state),
     });
   }
 
+  /**
+   * Reconciles the persisted store after each drain: updates `lastSynced` and
+   * the UI-facing `syncStatus`, persists a snapshot via the persistence layer,
+   * and broadcasts the change to other tabs.
+   */
+  public async recordDrainResult(result: DrainResult, pending = 0): Promise<void> {
+    const syncStatus = deriveSyncStatus(result, pending);
+
+    useStore.setState((state: any) => ({
+      app: {
+        ...state.app,
+        lastSynced: Date.now(),
+        syncStatus,
+      },
+    }));
+
+    try {
+      await persistenceLayer.setJSON(SYNC_STATE_KEY, {
+        lastSyncTime: result.lastSyncTime,
+        success: result.success,
+        syncedItems: result.syncedItems,
+        conflicts: result.conflicts,
+        syncStatus,
+        pending,
+      });
+    } catch (error) {
+      logger.error('[SyncEngine] Failed to persist sync state', { error });
+    }
+
+    this.broadcastState(useStore.getState());
+  }
+
+  /** Latest persisted sync snapshot (survives restarts). */
+  public async getDrainSnapshot() {
+    return persistenceLayer.getJSON<{
+      lastSyncTime: string;
+      success: boolean;
+      syncedItems: number;
+      conflicts: number;
+      syncStatus: SyncStatusState;
+      pending: number;
+    }>(SYNC_STATE_KEY);
+  }
+
   public disconnect() {
     this.unsubscribeReconnect?.();
     this.unsubscribeReconnect = null;