diff --git a/app/[communitySlug]/admin/members/page.tsx b/app/[communitySlug]/admin/members/page.tsx
index 5cf6bda..b679d3f 100644
--- a/app/[communitySlug]/admin/members/page.tsx
+++ b/app/[communitySlug]/admin/members/page.tsx
@@ -2,7 +2,8 @@
 
 import { useAccount } from "wagmi";
 import { useQuery, useInfiniteQuery, useMutation, useQueryClient } from "@tanstack/react-query";
-import { getApi, type MemberRow, type Role } from "@/lib/api";
+import { getApi, type MemberRow, type MutationResult, type Role } from "@/lib/api";
+import { withOfflineMutationQueue } from "@/lib/api/offline-mutations";
 import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
 import { Button } from "@/components/ui/button";
 import { Input } from "@/components/ui/input";
@@ -248,9 +249,12 @@ export default function MembersPage() {
     isError: mutateError,
     error: mutateErrorValue,
     reset: resetMutation,
-  } = useMutation<{ status: 'executed' | 'pending'; pendingActionId?: string }, unknown, AssignRoleInput, { previousQueries?: [any, any][]; auditId: string }>({
+  } = useMutation<MutationResult, unknown, AssignRoleInput, { previousQueries?: [any, any][]; auditId: string }>({
     mutationFn: (input) =>
-      getApi(address, authSession?.token, communitySlug).assignRole(input.address, input.role),
+      withOfflineMutationQueue(
+        getApi(address, authSession?.token, communitySlug),
+        communitySlug,
+      ).assignRole(input.address, input.role),
     // Auth errors are handled via registerPendingRetry — do not auto-retry 401s
     // to avoid racing with the re-auth banner flow.
     retry: false,
@@ -313,6 +317,23 @@ export default function MembersPage() {
         return;
       }
 
+      if (data.status === 'queued') {
+        // Offline — keep the optimistic update applied by onMutate rather
+        // than rolling back; it reflects what will happen once
+        // components/offline/mutation-queue-sync.tsx replays this mutation.
+        // The audit log entry is left in its "pending" state (rather than
+        // marked "success") since the mutation hasn't actually happened yet;
+        // this page has no way to hear back once replay completes later.
+        addToast({
+          tone: "warning",
+          title: "Action queued",
+          description: `Assigning ${input.role} to ${input.address.slice(0, 6)}…${input.address.slice(-4)} is queued. It will automatically sync when you're back online.`,
+        });
+        setAddr("");
+        resetMutation();
+        return;
+      }
+
       setAuditLog((prev) =>
         prev.map((entry) =>
           entry.id === context?.auditId ? { ...entry, status: "success" } : entry
@@ -407,13 +428,16 @@ export default function MembersPage() {
     mutateErrorValue instanceof AuthError && mutateErrorValue.code === "unauthorized";
 
   const removeRoleMutation = useMutation<
-    { status: 'executed' | 'pending'; pendingActionId?: string },
+    MutationResult,
     unknown,
     AssignRoleInput,
     { previousQueries?: [any, any][]; auditId: string }
   >({
     mutationFn: (input) =>
-      getApi(address, authSession?.token, communitySlug).removeRole(input.address, input.role),
+      withOfflineMutationQueue(
+        getApi(address, authSession?.token, communitySlug),
+        communitySlug,
+      ).removeRole(input.address, input.role),
     // Auth errors are handled via registerPendingRetry — do not auto-retry 401s.
     retry: false,
     onMutate: async (input) => {
@@ -471,6 +495,20 @@ export default function MembersPage() {
         return;
       }
 
+      if (data.status === 'queued') {
+        // Offline — keep the optimistic update applied by onMutate; the
+        // audit log entry stays "pending" since removal hasn't actually
+        // happened yet (see the assignRole mutation above for the same
+        // reasoning).
+        addToast({
+          tone: "warning",
+          title: "Action queued",
+          description: `Removing ${input.role} from ${input.address.slice(0, 6)}…${input.address.slice(-4)} is queued. It will automatically sync when you're back online.`,
+        });
+        resetMutation();
+        return;
+      }
+
       setAuditLog((prev) =>
         prev.map((entry) =>
           entry.id === context?.auditId ? { ...entry, status: "success" } : entry
diff --git a/app/[communitySlug]/admin/policies/page.tsx b/app/[communitySlug]/admin/policies/page.tsx
index 947d193..f9087a4 100644
--- a/app/[communitySlug]/admin/policies/page.tsx
+++ b/app/[communitySlug]/admin/policies/page.tsx
@@ -1,11 +1,12 @@
 "use client";
 
-import { useEffect, useId, useState, useMemo } from "react";
+import { useEffect, useId, useRef, useState, useMemo } from "react";
 import { useAccount } from "wagmi";
 import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
 import {
   getApi,
   type AccessPolicy,
+  type MutationResult,
   type Resource,
   MembershipTier,
   Role,
@@ -43,6 +44,11 @@ import {
   storePolicyDraft,
 } from "@/lib/policy-drafts";
 import { PolicyConflictDialog } from "@/components/ui/policy-conflict-dialog";
+import {
+  buildPolicyConflictContext,
+  type PolicyConflictContext,
+} from "@/lib/api/policy-conflict";
+import { withOfflineMutationQueue } from "@/lib/api/offline-mutations";
 import { ScenarioSelector } from "@/components/developer/scenario-selector";
 import { config } from "@/lib/config";
 const ALL_ROLES: Role[] = ["member", "moderator", "admin"];
@@ -304,12 +310,17 @@ export default function PoliciesPage() {
   );
   
   // Conflict detection state
-  const [conflictState, setConflictState] = useState<{
-    attemptedPolicy: AccessPolicy;
-    currentPolicy?: AccessPolicy;
-  } | null>(null);
+  const [conflictState, setConflictState] = useState<PolicyConflictContext | null>(null);
   const [isLoadingConflictData, setIsLoadingConflictData] = useState(false);
 
+  // Tracks the most recent mutation's result status so onSettled can skip
+  // invalidating the policies query when the mutation was only queued for
+  // offline replay — there's nothing new on the server yet, and refetching
+  // now would just overwrite the optimistic update with stale data (see
+  // components/offline/mutation-queue-sync.tsx for when the real
+  // invalidation happens, once replay actually succeeds).
+  const lastMutationStatusRef = useRef<MutationResult["status"] | null>(null);
+
   const {
     data: policies,
     isLoading,
@@ -339,11 +350,15 @@ export default function PoliciesPage() {
     isError: mutateError,
     error: mutateErrorValue,
     reset: resetMutation,
-  } = useMutation<{ status: 'executed' | 'pending'; pendingActionId?: string }, unknown, AccessPolicy, PolicyRollback>({
+  } = useMutation<MutationResult, unknown, AccessPolicy, PolicyRollback>({
     mutationFn: (policy: AccessPolicy) =>
-      getApi(address, authSession?.token, communitySlug).updatePolicy(policy),
+      withOfflineMutationQueue(
+        getApi(address, authSession?.token, communitySlug),
+        communitySlug,
+      ).updatePolicy(policy),
 
     onMutate: async (policy) => {
+      lastMutationStatusRef.current = null;
       await qc.cancelQueries({ queryKey: queryKeys.policies.all(communitySlug) });
       const previousPolicies = qc.getQueryData<AccessPolicy[]>(
         queryKeys.policies.all(communitySlug),
@@ -362,6 +377,7 @@ export default function PoliciesPage() {
     },
 
     onSuccess: (data, policy, context) => {
+      lastMutationStatusRef.current = data.status;
       if (data.status === 'pending') {
         qc.setQueryData(queryKeys.policies.all(communitySlug), context?.previousPolicies);
         addToast({
@@ -378,6 +394,26 @@ export default function PoliciesPage() {
         return;
       }
 
+      if (data.status === 'queued') {
+        // Offline — the optimistic update already reflects the attempted
+        // change locally; leave it in place until replay confirms it
+        // (components/offline/mutation-queue-sync.tsx), rather than rolling
+        // back to the previous server state.
+        addToast({
+          tone: "warning",
+          title: "Action queued",
+          description: `Your update to "${policy.resourceId}" is queued. It will automatically sync when you're back online.`,
+        });
+        setSuccessMessage("");
+        setRollbackMessage("");
+        clearPolicyDraft(policy.resourceId);
+        clearPolicyDraft("");
+        setEditingResourceId(null);
+        setShowCreateForm(false);
+        resetMutation();
+        return;
+      }
+
       addToast({
         tone: "success",
         title: `Policy saved for "${policy.resourceId}"`,
@@ -439,25 +475,13 @@ export default function PoliciesPage() {
 
       // Check for conflict error (409)
       if (isApiError(err) && err.status === 409) {
-        // Fetch the current version of the policy from the server
         setIsLoadingConflictData(true);
-        getApi(address, authSession?.token, communitySlug)
-          .getPolicy(policy.resourceId)
-          .then((currentPolicy) => {
-            setConflictState({
-              attemptedPolicy: policy,
-              currentPolicy: currentPolicy ?? undefined,
-            });
-          })
-          .catch(() => {
-            // If we can't fetch the current policy, still show the dialog
-            setConflictState({
-              attemptedPolicy: policy,
-            });
-          })
-          .finally(() => {
-            setIsLoadingConflictData(false);
-          });
+        buildPolicyConflictContext(
+          getApi(address, authSession?.token, communitySlug),
+          policy,
+        )
+          .then(setConflictState)
+          .finally(() => setIsLoadingConflictData(false));
       } else if (!(err instanceof AuthError)) {
         // Non-auth, non-conflict errors — show a toast with the error message
         addToast({
@@ -480,7 +504,12 @@ export default function PoliciesPage() {
 
     onSettled: () => {
       setPendingPolicyId(null);
-      qc.invalidateQueries({ queryKey: queryKeys.policies.all(communitySlug) });
+      // Skip invalidating when the mutation was only queued for offline
+      // replay — there's nothing new on the server yet (see
+      // lastMutationStatusRef above).
+      if (lastMutationStatusRef.current !== 'queued') {
+        qc.invalidateQueries({ queryKey: queryKeys.policies.all(communitySlug) });
+      }
     },
   });
 
diff --git a/app/layout.tsx b/app/layout.tsx
index 38d30fa..bfee7a6 100644
--- a/app/layout.tsx
+++ b/app/layout.tsx
@@ -5,6 +5,7 @@ import { Nav } from '@/components/nav'
 import { SwRegistrar } from '@/components/sw-registrar'
 import { BackendHealthCheck } from '@/components/backend-health-check'
 import { SyncStatusBanner } from '@/components/ui/sync-status-banner'
+import { MutationQueueSync } from '@/components/offline/mutation-queue-sync'
 import { ThemeProvider } from '@/components/theme-provider'
 export const metadata: Metadata = {
   title: {
@@ -38,6 +39,9 @@ export default function RootLayout({ children }: { children: React.ReactNode })
             <BackendHealthCheck />
             {/* Offline/Degraded status banner */}
             <SyncStatusBanner className="mb-4 w-full" />
+            {/* Drains the durable offline mutation queue on reconnect and
+                hosts the conflict dialog for replayed policy updates */}
+            <MutationQueueSync />
             <Nav />
             <main className="mx-auto max-w-6xl px-4 py-6">{children}</main>
           </RootProviders>
diff --git a/components/offline/mutation-queue-sync.tsx b/components/offline/mutation-queue-sync.tsx
new file mode 100644
index 0000000..b797234
--- /dev/null
+++ b/components/offline/mutation-queue-sync.tsx
@@ -0,0 +1,158 @@
+"use client";
+
+/**
+ * components/offline/mutation-queue-sync.tsx
+ *
+ * Always-mounted (see app/layout.tsx) engine that replays
+ * lib/offline/mutation-queue.ts against the live API whenever the app comes
+ * back online, one mutation at a time, FIFO.
+ *
+ * This lives above both admin pages — rather than inside either — because
+ * the queue can hold a mix of assignRole/removeRole (queued from the
+ * Members page) and updatePolicy (queued from the Policies page)
+ * mutations, and FIFO order must be preserved across that mix regardless
+ * of which admin page (if any) happens to be mounted when the app
+ * reconnects; a page-scoped drain loop could only ever replay its own
+ * mutation types.
+ *
+ * Renders nothing in the common case; only mounts PolicyConflictDialog when
+ * a replayed updatePolicy hits a 409 — reusing the exact same dialog
+ * component and conflict-context helper
+ * (lib/api/policy-conflict.ts) the live Policies page uses for a live
+ * conflict, so the resolution UX is identical either way.
+ */
+
+import { useCallback, useEffect, useState } from "react";
+import { useAccount } from "wagmi";
+import { useQueryClient } from "@tanstack/react-query";
+import { getApi } from "@/lib/api";
+import type { AccessPolicy } from "@/lib/api/types";
+import { useSiweAuth } from "@/lib/wallet/providers";
+import { useSyncStatus } from "@/lib/offline/use-sync-status";
+import {
+  drainMutationQueue,
+  type MutationReplayApi,
+  type ReplayOutcome,
+} from "@/lib/offline/mutation-replay";
+import { mutationQueue, type QueuedMutation } from "@/lib/offline/mutation-queue";
+import type { PolicyConflictContext } from "@/lib/api/policy-conflict";
+import { queryKeys, reconcileMemberRoleCache } from "@/lib/query";
+import { PolicyConflictDialog } from "@/components/ui/policy-conflict-dialog";
+
+interface ConflictState {
+  mutation: QueuedMutation;
+  context: PolicyConflictContext;
+}
+
+export function MutationQueueSync() {
+  const { address } = useAccount();
+  const { authSession } = useSiweAuth();
+  const { isOnline } = useSyncStatus();
+  const qc = useQueryClient();
+
+  const [conflict, setConflict] = useState<ConflictState | null>(null);
+
+  const resolveApi = useCallback(
+    (communitySlug: string): MutationReplayApi =>
+      getApi(address, authSession?.token, communitySlug),
+    [address, authSession?.token],
+  );
+
+  const runDrain = useCallback(async () => {
+    const outcome: ReplayOutcome = await drainMutationQueue(resolveApi, {
+      onMutationSucceeded: (mutation) => {
+        if (mutation.type === "updatePolicy") {
+          void qc.invalidateQueries({
+            queryKey: queryKeys.policies.all(mutation.communitySlug),
+          });
+          return;
+        }
+        reconcileMemberRoleCache(
+          qc,
+          {
+            address: mutation.payload.address,
+            role: mutation.payload.role,
+            action: mutation.type === "assignRole" ? "assign" : "remove",
+          },
+          mutation.communitySlug,
+        );
+      },
+    });
+
+    if (outcome.kind === "conflict") {
+      setConflict({ mutation: outcome.mutation, context: outcome.context });
+    }
+    // 'drained' / 'blocked' / 'skipped' need no UI here — 'blocked' just
+    // waits for the next reconnect (or token refresh) to try again; the
+    // pending count on SyncStatusBanner already reflects the outstanding
+    // item either way.
+  }, [resolveApi, qc]);
+
+  // Replay on reconnect, and on mount if already online (e.g. the queue was
+  // populated in a previous session and the page just (re)loaded online).
+  // Also re-attempt whenever the SIWE token changes — a mutation blocked on
+  // an expired session (401, not a network error) should resume once the
+  // admin re-authenticates, without waiting for another connectivity flip.
+  useEffect(() => {
+    if (!isOnline) return;
+    void runDrain();
+  }, [isOnline, authSession?.token, runDrain]);
+
+  if (!conflict) return null;
+
+  const { mutation, context } = conflict;
+
+  // Reload: give up the queued edit and show what's actually on the
+  // server — matches the live dialog's "Reload Latest Version" intent.
+  const handleReload = () => {
+    void (async () => {
+      await mutationQueue.remove(mutation.id);
+      void qc.invalidateQueries({ queryKey: queryKeys.policies.all(mutation.communitySlug) });
+      setConflict(null);
+      void runDrain();
+    })();
+  };
+
+  // Force overwrite: replay the same policy without its `updatedAt` version
+  // token, bypassing the concurrency check — identical trick to the live
+  // dialog's force-overwrite path.
+  const handleForceOverwrite = () => {
+    void (async () => {
+      const { updatedAt, ...policyWithoutVersion } = context.attemptedPolicy;
+      try {
+        await resolveApi(mutation.communitySlug).updatePolicy(
+          policyWithoutVersion as AccessPolicy,
+        );
+        await mutationQueue.remove(mutation.id);
+        void qc.invalidateQueries({ queryKey: queryKeys.policies.all(mutation.communitySlug) });
+      } catch {
+        // Still couldn't save (offline again, another conflict, etc.) —
+        // leave it queued; the next drain attempt will surface a fresh
+        // conflict (or succeed) rather than losing the admin's change.
+        await mutationQueue.incrementRetryCount(mutation.id);
+      }
+      setConflict(null);
+      void runDrain();
+    })();
+  };
+
+  // Cancel: dismiss without forcing a refetch — the admin can decide what
+  // to do next, same as closing the live dialog leaves the form untouched.
+  const handleCancel = () => {
+    void (async () => {
+      await mutationQueue.remove(mutation.id);
+      setConflict(null);
+      void runDrain();
+    })();
+  };
+
+  return (
+    <PolicyConflictDialog
+      attemptedPolicy={context.attemptedPolicy}
+      currentPolicy={context.currentPolicy}
+      onReload={handleReload}
+      onForceOverwrite={handleForceOverwrite}
+      onCancel={handleCancel}
+    />
+  );
+}
diff --git a/components/ui/sync-status-banner.tsx b/components/ui/sync-status-banner.tsx
index 48e1224..b148cef 100644
--- a/components/ui/sync-status-banner.tsx
+++ b/components/ui/sync-status-banner.tsx
@@ -3,17 +3,24 @@
 /**
  * SyncStatusBanner
  *
- * Displays connectivity and cache-freshness state for member-facing dashboard
- * read surfaces. Renders nothing when the browser is online and not syncing.
+ * Displays connectivity, cache-freshness, and offline-mutation-queue state.
+ * Renders nothing when the browser is online, not syncing, and no admin
+ * mutations are queued or replaying.
  *
  * States:
- *   • Online + syncing       — "Syncing…" spinner, auto-dismisses on completion
- *   • Offline + has cache    — amber banner: "Offline — showing cached data" +
- *                              "Last updated N minutes ago"
- *   • Offline + no cache     — red banner: "Offline — no cached data available"
+ *   • Online + syncing/replaying — "Syncing…" spinner (cache refresh and/or
+ *                                  queued mutation replay), auto-dismisses
+ *                                  on completion
+ *   • Offline + has cache        — amber banner: "Offline — showing cached
+ *                                  data" + "Last updated N minutes ago"
+ *   • Offline + no cache         — red banner: "Offline — no cached data
+ *                                  available"
+ *   • Any of the above may additionally show "<N> action(s) queued" when
+ *     lib/offline/mutation-queue.ts has pending admin mutations.
  */
 
 import { useSyncStatus } from '@/lib/offline/use-sync-status'
+import { useMutationQueueStatus } from '@/lib/offline/use-mutation-queue-status'
 import { cn } from '@/lib/utils'
 
 function formatRelativeTime(iso: string): string {
@@ -29,22 +36,39 @@ function formatRelativeTime(iso: string): string {
   return `${days} day${days !== 1 ? 's' : ''} ago`
 }
 
+function queuedActionsLabel(queuedCount: number): string {
+  return `${queuedCount} action${queuedCount === 1 ? '' : 's'} queued`
+}
+
+/** Extra line appended to the offline banners noting queued admin mutations. */
+function QueuedMutationsNote({ queuedCount }: { queuedCount: number }) {
+  if (queuedCount <= 0) return null
+  return (
+    <span className="pl-4 text-xs opacity-90">
+      {queuedActionsLabel(queuedCount)} — will sync automatically once you&apos;re back online.
+    </span>
+  )
+}
+
 export function SyncStatusBanner({ className }: { className?: string }) {
   const { isOnline, isBackendReachable, lastUpdatedAt, isSyncing } = useSyncStatus()
+  const { queuedCount, isReplaying } = useMutationQueueStatus()
   // True browser connectivity, independent of backend reachability — lets us
   // tell "you're offline" apart from "the configured backend can't be reached"
   const browserOnline = typeof navigator !== 'undefined' ? navigator.onLine : true
+  const hasQueuedWork = queuedCount > 0 || isReplaying
 
-  // Nothing to show when we are online and not mid-sync
-  if (isOnline && !isSyncing) return null
+  // Nothing to show when we are online, not mid-sync, and nothing is queued
+  if (isOnline && !isSyncing && !hasQueuedWork) return null
 
-  // Brief "syncing" indicator shown on reconnect while background fetch runs
-  if (isOnline && isSyncing) {
+  // Brief "syncing" indicator shown on reconnect while background fetch
+  // and/or queued-mutation replay runs
+  if (isOnline && (isSyncing || hasQueuedWork)) {
     return (
       <div
         role="status"
         aria-live="polite"
-        aria-label="Refreshing membership data"
+        aria-label={isReplaying ? 'Syncing queued actions' : 'Refreshing membership data'}
         className={cn(
           'flex items-center gap-2 rounded-md border border-blue-200 bg-blue-50 px-3 py-2 text-sm text-blue-800 dark:border-blue-800/40 dark:bg-blue-900/20 dark:text-blue-200',
           className,
@@ -62,7 +86,13 @@ export function SyncStatusBanner({ className }: { className?: string }) {
         >
           <path d="M21.5 2v6h-6M2.5 22v-6h6M2 11.5a10 10 0 0 1 18.8-4.3M22 12.5a10 10 0 0 1-18.8 4.2" />
         </svg>
-        <span>Syncing latest membership data…</span>
+        <span>
+          {isReplaying
+            ? `Syncing ${queuedActionsLabel(queuedCount)}…`
+            : queuedCount > 0
+              ? `${queuedActionsLabel(queuedCount)} — waiting to sync…`
+              : 'Syncing latest membership data…'}
+        </span>
       </div>
     )
   }
@@ -93,6 +123,7 @@ export function SyncStatusBanner({ className }: { className?: string }) {
         >
           Last updated {formatRelativeTime(lastUpdatedAt)}
         </span>
+        <QueuedMutationsNote queuedCount={queuedCount} />
       </div>
     )
   }
@@ -108,19 +139,22 @@ export function SyncStatusBanner({ className }: { className?: string }) {
         aria-live="assertive"
         aria-label="Backend unreachable"
         className={cn(
-          'flex items-center gap-2 rounded-md border border-destructive/40 bg-destructive/5 px-3 py-2 text-sm text-destructive',
+          'flex flex-col gap-1 rounded-md border border-destructive/40 bg-destructive/5 px-3 py-2 text-sm text-destructive',
           className,
         )}
       >
-        <span
-          className="inline-block h-2 w-2 shrink-0 rounded-full bg-destructive"
-          aria-hidden="true"
-        />
-        <span>
-          Can&apos;t reach the backend service. This usually means the app is
-          misconfigured — check that <code>NEXT_PUBLIC_CORE_API_URL</code> is
-          set correctly for this deployment, or that the backend is running.
-        </span>
+        <div className="flex items-center gap-2">
+          <span
+            className="inline-block h-2 w-2 shrink-0 rounded-full bg-destructive"
+            aria-hidden="true"
+          />
+          <span>
+            Can&apos;t reach the backend service. This usually means the app is
+            misconfigured — check that <code>NEXT_PUBLIC_CORE_API_URL</code> is
+            set correctly for this deployment, or that the backend is running.
+          </span>
+        </div>
+        <QueuedMutationsNote queuedCount={queuedCount} />
       </div>
     )
   }
@@ -132,18 +166,21 @@ export function SyncStatusBanner({ className }: { className?: string }) {
       aria-live="assertive"
       aria-label="Offline — no cached data available"
       className={cn(
-       'flex items-center gap-2 rounded-md border border-destructive/40 bg-destructive/5 px-3 py-2 text-sm text-destructive',
+       'flex flex-col gap-1 rounded-md border border-destructive/40 bg-destructive/5 px-3 py-2 text-sm text-destructive',
         className,
       )}
     >
-      <span
-        className="inline-block h-2 w-2 shrink-0 rounded-full bg-destructive"
-        aria-hidden="true"
-      />
-      <span>
-        Offline — no cached data available. Connect to a network to load your
-        membership.
-      </span>
+      <div className="flex items-center gap-2">
+        <span
+          className="inline-block h-2 w-2 shrink-0 rounded-full bg-destructive"
+          aria-hidden="true"
+        />
+        <span>
+          Offline — no cached data available. Connect to a network to load your
+          membership.
+        </span>
+      </div>
+      <QueuedMutationsNote queuedCount={queuedCount} />
     </div>
   )
 }
diff --git a/lib/api/offline-mutations.ts b/lib/api/offline-mutations.ts
new file mode 100644
index 0000000..2781d9f
--- /dev/null
+++ b/lib/api/offline-mutations.ts
@@ -0,0 +1,93 @@
+/**
+ * lib/api/offline-mutations.ts
+ *
+ * Thin wrapper around an {@link AccessApi} client that makes
+ * assignRole/removeRole/updatePolicy durable-offline instead of failing.
+ *
+ * Deliberately NOT baked into LiveAccessApi/MockAccessApi themselves: both
+ * clients already implement the full AccessApi contract and are exercised
+ * directly by a lot of existing tests, so wrapping at the call site (where
+ * admin pages construct their client) keeps this feature additive and
+ * avoids touching either implementation. Every method other than the three
+ * mutations below passes straight through to the wrapped client.
+ */
+
+import type { AccessApi, AccessPolicy, MutationResult, Role } from './types'
+import { isNetworkError, OfflineError } from './errors'
+import {
+  mutationQueue,
+  type PayloadFor,
+  type QueuedMutationType,
+} from '../offline/mutation-queue'
+
+function isOffline(): boolean {
+  return typeof navigator !== 'undefined' && navigator.onLine === false
+}
+
+/**
+ * True for the two offline signals this wrapper queues on: the browser had
+ * no connection when the request was attempted (isOffline(), checked by the
+ * caller before even trying), or the fetch itself failed at the transport
+ * level. Deliberately narrow — HTTP error responses (4xx/5xx, including the
+ * 409 conflict / 401 auth-expired paths) are real server answers, not
+ * connectivity failures, and must keep surfacing to the existing
+ * error-handling flows (PolicyConflictDialog, registerPendingRetry) instead
+ * of being silently queued.
+ */
+function isOfflineFailure(err: unknown): boolean {
+  return isNetworkError(err) || err instanceof OfflineError
+}
+
+async function queueOrCall<T extends QueuedMutationType>(
+  type: T,
+  payload: PayloadFor<T>,
+  communitySlug: string,
+  call: () => Promise<MutationResult>,
+): Promise<MutationResult> {
+  if (isOffline()) {
+    await mutationQueue.enqueue(type, payload, communitySlug)
+    return { status: 'queued' }
+  }
+  try {
+    return await call()
+  } catch (err) {
+    if (isOfflineFailure(err)) {
+      await mutationQueue.enqueue(type, payload, communitySlug)
+      return { status: 'queued' }
+    }
+    throw err
+  }
+}
+
+/**
+ * Wraps `api` so assignRole/removeRole/updatePolicy enqueue themselves
+ * (see lib/offline/mutation-queue.ts) instead of throwing whenever the
+ * browser is offline or the request fails with a network error, and return
+ * `{ status: 'queued' }` instead. `communitySlug` is captured on the queued
+ * record so replay later targets the right community regardless of which
+ * route is active when it runs (components/offline/mutation-queue-sync.tsx).
+ */
+export function withOfflineMutationQueue(api: AccessApi, communitySlug: string): AccessApi {
+  const queueingAssignRole = (address: string, role: Role) =>
+    queueOrCall('assignRole', { address, role }, communitySlug, () =>
+      api.assignRole(address, role),
+    )
+
+  const queueingRemoveRole = (address: string, role: Role) =>
+    queueOrCall('removeRole', { address, role }, communitySlug, () =>
+      api.removeRole(address, role),
+    )
+
+  const queueingUpdatePolicy = (policy: AccessPolicy) =>
+    queueOrCall('updatePolicy', { policy }, communitySlug, () => api.updatePolicy(policy))
+
+  return new Proxy(api, {
+    get(target, prop, receiver) {
+      if (prop === 'assignRole') return queueingAssignRole
+      if (prop === 'removeRole') return queueingRemoveRole
+      if (prop === 'updatePolicy') return queueingUpdatePolicy
+      const value = Reflect.get(target, prop, receiver)
+      return typeof value === 'function' ? value.bind(target) : value
+    },
+  }) as AccessApi
+}
diff --git a/lib/api/policy-conflict.ts b/lib/api/policy-conflict.ts
new file mode 100644
index 0000000..c347970
--- /dev/null
+++ b/lib/api/policy-conflict.ts
@@ -0,0 +1,34 @@
+/**
+ * lib/api/policy-conflict.ts
+ *
+ * Shared helper for building the context PolicyConflictDialog needs after a
+ * 409 on updatePolicy: the policy the caller attempted to save, plus a
+ * best-effort fetch of the server's current version for the diff view.
+ *
+ * Used by both the live edit flow
+ * (app/[communitySlug]/admin/policies/page.tsx) and the offline replay
+ * engine (lib/offline/mutation-replay.ts via components/offline/mutation-queue-sync.tsx)
+ * so the "what do we show in the conflict dialog" logic exists in exactly
+ * one place.
+ */
+
+import type { AccessApi, AccessPolicy } from './types'
+
+export interface PolicyConflictContext {
+  attemptedPolicy: AccessPolicy
+  currentPolicy?: AccessPolicy
+}
+
+export async function buildPolicyConflictContext(
+  api: Pick<AccessApi, 'getPolicy'>,
+  attemptedPolicy: AccessPolicy,
+): Promise<PolicyConflictContext> {
+  try {
+    const currentPolicy = await api.getPolicy(attemptedPolicy.resourceId)
+    return { attemptedPolicy, currentPolicy: currentPolicy ?? undefined }
+  } catch {
+    // If we can't fetch the current policy, still surface the dialog —
+    // the admin needs to know a conflict happened even without a diff.
+    return { attemptedPolicy }
+  }
+}
diff --git a/lib/api/types.ts b/lib/api/types.ts
index 34b9c57..de62b43 100644
--- a/lib/api/types.ts
+++ b/lib/api/types.ts
@@ -394,8 +394,38 @@ export interface ApprovalConfig {
   updatePolicy: number
 }
 
+/**
+ * {@link Community} as actually returned in mock mode, which additionally
+ * carries multi-admin approval thresholds. Kept separate from the
+ * auto-generated `Community` interface (test/fixtures/openapi.json) rather
+ * than added to it directly, since `approvalConfig` isn't part of the
+ * OpenAPI schema yet.
+ */
+export interface CommunityWithApprovalConfig extends Community {
+  approvalConfig?: ApprovalConfig
+}
+
 export type PendingActionType = 'assignRole' | 'removeRole' | 'updatePolicy'
 
+/**
+ * Result of an admin write mutation (assignRole/removeRole/updatePolicy).
+ *
+ * - 'executed' — applied immediately.
+ * - 'pending'  — multi-admin approval threshold not yet met (see
+ *   {@link ApprovalConfig} / {@link PendingActionType}); unrelated to
+ *   connectivity.
+ * - 'queued'   — the caller was offline or the request failed with a network
+ *   error; the mutation was persisted to the durable offline mutation queue
+ *   (see lib/offline/mutation-queue.ts) instead of failing, and will be
+ *   replayed automatically once the app is back online.
+ */
+export type MutationResultStatus = 'executed' | 'pending' | 'queued'
+
+export interface MutationResult {
+  status: MutationResultStatus
+  pendingActionId?: string
+}
+
 export interface PendingActionPayload {
   address?: string
   role?: string
@@ -790,6 +820,22 @@ export interface MemberAccessApi {
   rejectConnectionRequest(targetAddress: string): Promise<void>
 }
 
+export interface RoleDistributionEntry {
+  role: Role
+  count: number
+}
+
+/**
+ * Analytics surface exposed on {@link AdminAccessApi}. Both LiveAccessApi
+ * and MockAccessApi implement this as a plain object of async methods
+ * (see lib/api/live.ts / lib/api/mock.ts's `analytics` field).
+ */
+export interface AnalyticsDataSource {
+  getMembershipTrend(signal?: AbortSignal): Promise<MemberGrowthDataPoint[]>
+  getRoleDistribution(signal?: AbortSignal): Promise<RoleDistributionEntry[]>
+  getAccessAttempts(signal?: AbortSignal): Promise<ResourceAccessCount[]>
+}
+
 /**
  * Authenticated admin queries and mutations.
  * These methods require a valid SIWE token context.
@@ -797,6 +843,8 @@ export interface MemberAccessApi {
 export interface AdminAccessApi {
   // ── Admin queries & mutations (require a valid SIWE token context) ────────
   listWebhookEvents(signal?: AbortSignal): Promise<WebhookEventLog[]>
+  /** Paginated/filterable variant of listWebhookEvents used by app/admin/events. */
+  listAdminEvents(params?: AdminEventFilterParams): Promise<Paginated<WebhookEvent>>
   /**
    * Subscribe to the admin webhook event stream.
    *
@@ -818,16 +866,16 @@ export interface AdminAccessApi {
   approveAction(id: string): Promise<void>
   rejectAction(id: string): Promise<void>
   updateApprovalConfig(config: ApprovalConfig): Promise<void>
-  
-  assignRole(address: string, role: Role): Promise<{ status: 'executed' | 'pending'; pendingActionId?: string }>
-  removeRole(address: string, role: Role): Promise<{ status: 'executed' | 'pending'; pendingActionId?: string }>
-  updatePolicy(policy: AccessPolicy): Promise<{ status: 'executed' | 'pending'; pendingActionId?: string }>
+
+  assignRole(address: string, role: Role): Promise<MutationResult>
+  removeRole(address: string, role: Role): Promise<MutationResult>
+  updatePolicy(policy: AccessPolicy): Promise<MutationResult>
 
   // ── Moderation Queue ──
   listReports(signal?: AbortSignal): Promise<ModerationReport[]>
   getReport(id: string, signal?: AbortSignal): Promise<ModerationReport | null>
   updateReportState(id: string, state: ModerationState, updates?: Partial<ModerationReport>): Promise<void>
-  
+
   // ── Governance (requires SIWE auth for voting/proposals) ──
   listProposals(params?: { filter?: ProposalStatus | ProposalType; limit?: number; cursor?: string }, signal?: AbortSignal): Promise<Proposal[]>
   getProposal(id: string, signal?: AbortSignal): Promise<Proposal | null>
@@ -840,7 +888,7 @@ export interface AdminAccessApi {
   closeProposalVoting(id: string): Promise<Proposal>
   resolveProposal(id: string, outcome: string): Promise<Proposal>
   deleteProposal(id: string): Promise<void>
-  
+
   // Analytics
   analytics: AnalyticsDataSource
 }
diff --git a/lib/offline/mutation-queue.ts b/lib/offline/mutation-queue.ts
new file mode 100644
index 0000000..12ee646
--- /dev/null
+++ b/lib/offline/mutation-queue.ts
@@ -0,0 +1,260 @@
+/**
+ * lib/offline/mutation-queue.ts
+ *
+ * Durable FIFO queue for admin write mutations (assignRole / removeRole /
+ * updatePolicy) attempted while offline. Backed by IndexedDB so it survives
+ * a full page reload — sessionStorage/localStorage are unsuitable here since
+ * they're synchronous and size-limited, and this data needs to persist
+ * exactly like the mutations it represents.
+ *
+ * Storage access is behind the small {@link QueueStorage} interface so it
+ * can be swapped out. This repo's test suite runs under plain Node
+ * (`node --test`, no jsdom/IndexedDB — see package.json's "test" script),
+ * so tests construct a queue via {@link createMutationQueue} over an
+ * in-memory {@link createInMemoryQueueStorage} backing store instead of the
+ * real IndexedDB-backed one the app uses. The same in-memory storage doubles
+ * as a graceful runtime fallback if `indexedDB` is unavailable (e.g. private
+ * browsing in some browsers), matching this codebase's existing "best effort,
+ * never throw" storage conventions (see lib/policy-drafts.ts).
+ */
+
+import type { AccessPolicy, Role } from '../api/types'
+
+export type QueuedMutationType = 'assignRole' | 'removeRole' | 'updatePolicy'
+
+export interface AssignRolePayload {
+  address: string
+  role: Role
+}
+
+export interface RemoveRolePayload {
+  address: string
+  role: Role
+}
+
+export interface UpdatePolicyPayload {
+  /**
+   * The full policy the admin attempted to save, including `updatedAt` (if
+   * any) — that field IS this app's optimistic-concurrency version token
+   * (see docs/POLICY_CONCURRENCY.md), so persisting the whole policy is
+   * sufficient for replay to correctly detect a 409 conflict later; no
+   * separate ETag/version field is needed.
+   */
+  policy: AccessPolicy
+}
+
+type QueuedMutationVariant =
+  | { type: 'assignRole'; payload: AssignRolePayload }
+  | { type: 'removeRole'; payload: RemoveRolePayload }
+  | { type: 'updatePolicy'; payload: UpdatePolicyPayload }
+
+export type QueuedMutation = QueuedMutationVariant & {
+  id: string
+  /** ISO timestamp when the mutation was queued — the primary FIFO sort key. */
+  queuedAt: string
+  /**
+   * Monotonically increasing (within this process's lifetime) tiebreaker for
+   * mutations enqueued within the same millisecond, where `queuedAt` alone
+   * can't distinguish order. Resets to 0 on reload, which is safe because a
+   * reload takes long enough in wall-clock time that `queuedAt` alone
+   * disambiguates anything queued before vs. after it.
+   */
+  sequence: number
+  /** Number of failed replay attempts so far. */
+  retryCount: number
+  /** Community the mutation targets, captured at enqueue time so replay
+   *  doesn't depend on whatever route happens to be active later. */
+  communitySlug: string
+}
+
+export type PayloadFor<T extends QueuedMutationType> = Extract<
+  QueuedMutationVariant,
+  { type: T }
+>['payload']
+
+export interface QueueStorage {
+  getAll(): Promise<QueuedMutation[]>
+  put(mutation: QueuedMutation): Promise<void>
+  delete(id: string): Promise<void>
+}
+
+// ── In-memory storage (test double + no-IndexedDB fallback) ────────────────
+
+export function createInMemoryQueueStorage(
+  backing: Map<string, QueuedMutation> = new Map(),
+): QueueStorage {
+  return {
+    async getAll() {
+      return Array.from(backing.values())
+    },
+    async put(mutation) {
+      backing.set(mutation.id, mutation)
+    },
+    async delete(id) {
+      backing.delete(id)
+    },
+  }
+}
+
+// ── IndexedDB storage (real, browser-persisted backend) ─────────────────────
+
+const DB_NAME = 'guildpass-offline-mutations'
+const DB_VERSION = 1
+const STORE_NAME = 'mutations'
+
+function hasIndexedDb(): boolean {
+  return typeof indexedDB !== 'undefined'
+}
+
+function openDb(): Promise<IDBDatabase> {
+  return new Promise((resolve, reject) => {
+    const request = indexedDB.open(DB_NAME, DB_VERSION)
+    request.onupgradeneeded = () => {
+      const db = request.result
+      if (!db.objectStoreNames.contains(STORE_NAME)) {
+        db.createObjectStore(STORE_NAME, { keyPath: 'id' })
+      }
+    }
+    request.onsuccess = () => resolve(request.result)
+    request.onerror = () => reject(request.error)
+  })
+}
+
+function createIndexedDbQueueStorage(): QueueStorage {
+  let dbPromise: Promise<IDBDatabase> | null = null
+  const getDb = () => {
+    if (!dbPromise) dbPromise = openDb()
+    return dbPromise
+  }
+
+  return {
+    async getAll() {
+      const db = await getDb()
+      return new Promise((resolve, reject) => {
+        const tx = db.transaction(STORE_NAME, 'readonly')
+        const request = tx.objectStore(STORE_NAME).getAll()
+        request.onsuccess = () => resolve(request.result as QueuedMutation[])
+        request.onerror = () => reject(request.error)
+      })
+    },
+    async put(mutation) {
+      const db = await getDb()
+      return new Promise((resolve, reject) => {
+        const tx = db.transaction(STORE_NAME, 'readwrite')
+        tx.objectStore(STORE_NAME).put(mutation)
+        tx.oncomplete = () => resolve()
+        tx.onerror = () => reject(tx.error)
+      })
+    },
+    async delete(id) {
+      const db = await getDb()
+      return new Promise((resolve, reject) => {
+        const tx = db.transaction(STORE_NAME, 'readwrite')
+        tx.objectStore(STORE_NAME).delete(id)
+        tx.oncomplete = () => resolve()
+        tx.onerror = () => reject(tx.error)
+      })
+    },
+  }
+}
+
+function defaultStorage(): QueueStorage {
+  return hasIndexedDb() ? createIndexedDbQueueStorage() : createInMemoryQueueStorage()
+}
+
+// ── Queue ─────────────────────────────────────────────────────────────────────
+
+function generateId(): string {
+  return globalThis.crypto?.randomUUID?.() ?? `${Date.now()}-${Math.random().toString(36).slice(2)}`
+}
+
+function byQueuedAtAscending(a: QueuedMutation, b: QueuedMutation): number {
+  if (a.queuedAt !== b.queuedAt) return a.queuedAt < b.queuedAt ? -1 : 1
+  // Same-millisecond tiebreak — `id` is a random UUID (not sortable by
+  // insertion order), so a monotonic sequence number is required here.
+  return a.sequence - b.sequence
+}
+
+export interface MutationQueue {
+  /** Persist a new mutation at the tail of the queue. */
+  enqueue<T extends QueuedMutationType>(
+    type: T,
+    payload: PayloadFor<T>,
+    communitySlug: string,
+  ): Promise<QueuedMutation>
+  /** All queued mutations, oldest first (FIFO). */
+  list(): Promise<QueuedMutation[]>
+  /** The oldest queued mutation, or null if the queue is empty. */
+  peek(): Promise<QueuedMutation | null>
+  remove(id: string): Promise<void>
+  incrementRetryCount(id: string): Promise<QueuedMutation | null>
+  count(): Promise<number>
+  /** Subscribe to any enqueue/remove/retry change. Returns an unsubscribe fn. */
+  subscribe(listener: () => void): () => void
+}
+
+export function createMutationQueue(storage: QueueStorage = defaultStorage()): MutationQueue {
+  const listeners = new Set<() => void>()
+  const notify = () => listeners.forEach((listener) => listener())
+  let sequenceCounter = 0
+
+  const list = async (): Promise<QueuedMutation[]> => {
+    const all = await storage.getAll()
+    return all.slice().sort(byQueuedAtAscending)
+  }
+
+  return {
+    async enqueue(type, payload, communitySlug) {
+      const mutation = {
+        id: generateId(),
+        type,
+        payload,
+        queuedAt: new Date().toISOString(),
+        sequence: sequenceCounter++,
+        retryCount: 0,
+        communitySlug,
+      } as QueuedMutation
+      await storage.put(mutation)
+      notify()
+      return mutation
+    },
+
+    list,
+
+    async peek() {
+      const all = await list()
+      return all[0] ?? null
+    },
+
+    async remove(id) {
+      await storage.delete(id)
+      notify()
+    },
+
+    async incrementRetryCount(id) {
+      const all = await storage.getAll()
+      const existing = all.find((m) => m.id === id)
+      if (!existing) return null
+      const updated: QueuedMutation = { ...existing, retryCount: existing.retryCount + 1 }
+      await storage.put(updated)
+      notify()
+      return updated
+    },
+
+    async count() {
+      const all = await storage.getAll()
+      return all.length
+    },
+
+    subscribe(listener) {
+      listeners.add(listener)
+      return () => {
+        listeners.delete(listener)
+      }
+    },
+  }
+}
+
+/** The app-wide singleton queue, backed by IndexedDB (or the in-memory
+ *  fallback if IndexedDB isn't available in this browser). */
+export const mutationQueue: MutationQueue = createMutationQueue()
diff --git a/lib/offline/mutation-replay.ts b/lib/offline/mutation-replay.ts
new file mode 100644
index 0000000..ee259b7
--- /dev/null
+++ b/lib/offline/mutation-replay.ts
@@ -0,0 +1,125 @@
+/**
+ * lib/offline/mutation-replay.ts
+ *
+ * Drains lib/offline/mutation-queue.ts strictly FIFO, one mutation at a
+ * time, awaiting each replay before starting the next. Framework-agnostic —
+ * the caller (components/offline/mutation-queue-sync.tsx) supplies a way to
+ * resolve an API client per community and is responsible for connectivity
+ * detection (via lib/offline/use-sync-status.ts) and for rendering
+ * PolicyConflictDialog on a 'conflict' outcome.
+ *
+ * Stops (without discarding anything) the moment a mutation can't be
+ * resolved automatically:
+ *  - an updatePolicy 409 surfaces as a 'conflict' outcome — never silently
+ *    overwritten or discarded, exactly like a live conflict would be;
+ *  - any other failure increments retryCount and surfaces as 'blocked'; the
+ *    item stays at the head of the queue so later items don't jump ahead of
+ *    it, preserving FIFO order. The caller is expected to try again on the
+ *    next reconnect (or the next time it's invoked).
+ *
+ * Concurrency: guarded by a module-level flag so at most one drain runs at
+ * a time no matter how many components call drainMutationQueue().
+ */
+
+import type { AccessPolicy, MutationResult, Role } from '../api/types'
+import { isApiError } from '../api/errors'
+import { buildPolicyConflictContext, type PolicyConflictContext } from '../api/policy-conflict'
+import { mutationQueue, type QueuedMutation } from './mutation-queue'
+
+/** The subset of AccessApi replay needs, scoped to one community. */
+export interface MutationReplayApi {
+  assignRole(address: string, role: Role): Promise<MutationResult>
+  removeRole(address: string, role: Role): Promise<MutationResult>
+  updatePolicy(policy: AccessPolicy): Promise<MutationResult>
+  getPolicy(resourceId: string): Promise<AccessPolicy | null>
+}
+
+/** Resolves the API client to replay a given community's mutations against. */
+export type ResolveReplayApi = (communitySlug: string) => MutationReplayApi
+
+export type ReplayOutcome =
+  | { kind: 'drained' }
+  | { kind: 'conflict'; mutation: QueuedMutation; context: PolicyConflictContext }
+  | { kind: 'blocked'; mutation: QueuedMutation; error: unknown }
+  /** Another drain was already in progress — this call was a no-op. */
+  | { kind: 'skipped' }
+
+export interface DrainHooks {
+  /** Called after each mutation is successfully replayed and removed from the queue. */
+  onMutationSucceeded?: (mutation: QueuedMutation) => void
+}
+
+let isDraining = false
+const replayListeners = new Set<() => void>()
+
+function setDraining(value: boolean): void {
+  isDraining = value
+  replayListeners.forEach((listener) => listener())
+}
+
+/** Whether a drain is currently in progress, in this tab. Mirrors the
+ *  get/subscribe shape of lib/api/backendStatus.ts's `backendOnline`. */
+export function isReplayingMutationQueue(): boolean {
+  return isDraining
+}
+
+export function subscribeMutationReplayState(listener: () => void): () => void {
+  replayListeners.add(listener)
+  return () => {
+    replayListeners.delete(listener)
+  }
+}
+
+function isConflictError(err: unknown): boolean {
+  return isApiError(err) && err.status === 409
+}
+
+async function executeMutation(api: MutationReplayApi, mutation: QueuedMutation): Promise<void> {
+  if (mutation.type === 'assignRole') {
+    await api.assignRole(mutation.payload.address, mutation.payload.role)
+    return
+  }
+  if (mutation.type === 'removeRole') {
+    await api.removeRole(mutation.payload.address, mutation.payload.role)
+    return
+  }
+  await api.updatePolicy(mutation.payload.policy)
+}
+
+export async function drainMutationQueue(
+  resolveApi: ResolveReplayApi,
+  hooks: DrainHooks = {},
+): Promise<ReplayOutcome> {
+  if (isDraining) return { kind: 'skipped' }
+  setDraining(true)
+  try {
+    for (;;) {
+      const next = await mutationQueue.peek()
+      if (!next) return { kind: 'drained' }
+
+      const api = resolveApi(next.communitySlug)
+
+      try {
+        await executeMutation(api, next)
+        await mutationQueue.remove(next.id)
+        hooks.onMutationSucceeded?.(next)
+      } catch (err) {
+        if (next.type === 'updatePolicy' && isConflictError(err)) {
+          const context = await buildPolicyConflictContext(api, next.payload.policy)
+          return { kind: 'conflict', mutation: next, context }
+        }
+
+        await mutationQueue.incrementRetryCount(next.id)
+        return { kind: 'blocked', mutation: next, error: err }
+      }
+    }
+  } finally {
+    setDraining(false)
+  }
+}
+
+/** Test-only: reset the module-level drain mutex between test cases. */
+export function __resetMutationReplayStateForTests(): void {
+  isDraining = false
+  replayListeners.clear()
+}
diff --git a/lib/offline/use-mutation-queue-status.ts b/lib/offline/use-mutation-queue-status.ts
new file mode 100644
index 0000000..2d98e6c
--- /dev/null
+++ b/lib/offline/use-mutation-queue-status.ts
@@ -0,0 +1,55 @@
+/**
+ * lib/offline/use-mutation-queue-status.ts
+ *
+ * React hook exposing the durable mutation queue's pending count and
+ * whether a replay is currently draining it — shared by
+ * components/ui/sync-status-banner.tsx (display) and
+ * components/offline/mutation-queue-sync.tsx (which drives the drain).
+ * Kept separate from lib/offline/use-sync-status.ts since that hook is
+ * connectivity-only; this one is queue-state-only. Both are plain
+ * subscriptions, so using them together never double-fires re-renders.
+ */
+
+'use client'
+
+import { useEffect, useState } from 'react'
+import { mutationQueue } from './mutation-queue'
+import { isReplayingMutationQueue, subscribeMutationReplayState } from './mutation-replay'
+
+export interface MutationQueueStatus {
+  /** Number of mutations currently queued for offline replay. */
+  queuedCount: number
+  /** True while the queue is actively being drained. */
+  isReplaying: boolean
+}
+
+export function useMutationQueueStatus(): MutationQueueStatus {
+  const [queuedCount, setQueuedCount] = useState(0)
+  const [isReplaying, setIsReplaying] = useState(isReplayingMutationQueue)
+
+  useEffect(() => {
+    let cancelled = false
+    const refreshCount = () => {
+      mutationQueue.count().then((count) => {
+        if (!cancelled) setQueuedCount(count)
+      })
+    }
+
+    refreshCount()
+    const unsubscribeQueue = mutationQueue.subscribe(refreshCount)
+    const unsubscribeReplay = subscribeMutationReplayState(() => {
+      setIsReplaying(isReplayingMutationQueue())
+      // A drain starting or finishing always changes (or is about to
+      // change) the queue count too.
+      refreshCount()
+    })
+
+    return () => {
+      cancelled = true
+      unsubscribeQueue()
+      unsubscribeReplay()
+    }
+  }, [])
+
+  return { queuedCount, isReplaying }
+}
diff --git a/scripts/sync-api-types.js b/scripts/sync-api-types.js
index 5ee386d..92ad12b 100644
--- a/scripts/sync-api-types.js
+++ b/scripts/sync-api-types.js
@@ -41,8 +41,38 @@ export interface ApprovalConfig {
   updatePolicy: number
 }
 
+/**
+ * {@link Community} as actually returned in mock mode, which additionally
+ * carries multi-admin approval thresholds. Kept separate from the
+ * auto-generated \`Community\` interface (test/fixtures/openapi.json) rather
+ * than added to it directly, since \`approvalConfig\` isn't part of the
+ * OpenAPI schema yet.
+ */
+export interface CommunityWithApprovalConfig extends Community {
+  approvalConfig?: ApprovalConfig
+}
+
 export type PendingActionType = 'assignRole' | 'removeRole' | 'updatePolicy'
 
+/**
+ * Result of an admin write mutation (assignRole/removeRole/updatePolicy).
+ *
+ * - 'executed' — applied immediately.
+ * - 'pending'  — multi-admin approval threshold not yet met (see
+ *   {@link ApprovalConfig} / {@link PendingActionType}); unrelated to
+ *   connectivity.
+ * - 'queued'   — the caller was offline or the request failed with a network
+ *   error; the mutation was persisted to the durable offline mutation queue
+ *   (see lib/offline/mutation-queue.ts) instead of failing, and will be
+ *   replayed automatically once the app is back online.
+ */
+export type MutationResultStatus = 'executed' | 'pending' | 'queued'
+
+export interface MutationResult {
+  status: MutationResultStatus
+  pendingActionId?: string
+}
+
 export interface PendingActionPayload {
   address?: string
   role?: string
@@ -249,6 +279,143 @@ export interface BackendSession {
   }
 }
 
+// ── Governance Types ──────────────────────────────────────────────────────────
+
+/**
+ * Proposal status lifecycle:
+ * - draft: Created by admin, not yet active
+ * - active: Open for voting by members
+ * - closed: Voting period ended, awaiting resolution
+ * - resolved: Outcome applied/executed
+ */
+export type ProposalStatus = 'draft' | 'active' | 'closed' | 'resolved'
+
+export type ProposalType = 'policy_change' | 'resource_addition' | 'rule_update' | 'other'
+
+export interface Proposal {
+  id: string
+  communityId: string
+  type: ProposalType
+  title: string
+  description: string
+  status: ProposalStatus
+  proposer: string
+  createdAt: string
+  votingStartsAt: string
+  votingEndsAt: string
+  /** JSON-encoded proposal-specific data (e.g., policy diff, resource spec). */
+  payload: Record<string, unknown>
+  /** Total voting weight available (sum of all role/tier weights). */
+  totalWeight: number
+  /** Vote counts and weighted results. */
+  votesSummary: VotesSummary
+}
+
+export interface VotesSummary {
+  totalVotes: number
+  weightsFor: number
+  weightsAgainst: number
+  weightsAbstain: number
+  percentFor?: number
+  percentAgainst?: number
+}
+
+export type VoteChoice = 'for' | 'against' | 'abstain'
+
+export interface Vote {
+  id: string
+  proposalId: string
+  voter: string
+  choice: VoteChoice
+  weight: number
+  /**
+   * Voter's tier/role at time of vote, used to calculate weight.
+   * { tier: 'pro', role: 'moderator' } for example.
+   */
+  voterContext?: {
+    tier?: MembershipTier
+    role?: Role
+  }
+  votedAt: string
+}
+
+export interface GovernanceApi {
+  // ── Member queries (read-only) ────────────────────────────────────────
+  /**
+   * List active and recent proposals.
+   * @param filter - Optional filter by status ('active', 'draft', 'closed', 'resolved') or type
+   * @param limit - Pagination limit (default 20)
+   * @param cursor - Pagination cursor
+   */
+  listProposals(params?: {
+    filter?: ProposalStatus | ProposalType
+    limit?: number
+    cursor?: string
+  }, signal?: AbortSignal): Promise<Proposal[]>
+
+  /**
+   * Get a single proposal by ID with full details and vote summary.
+   */
+  getProposal(id: string, signal?: AbortSignal): Promise<Proposal | null>
+
+  /**
+   * Get the authenticated member's vote on a proposal (if any).
+   */
+  getMemberVote(proposalId: string, signal?: AbortSignal): Promise<Vote | null>
+
+  /**
+   * List all votes on a proposal (for transparency).
+   */
+  listProposalVotes(proposalId: string, params?: {
+    limit?: number
+    cursor?: string
+  }, signal?: AbortSignal): Promise<Vote[]>
+
+  // ── Member mutations ──────────────────────────────────────────────────
+  /**
+   * Cast or update a vote on an active proposal.
+   * Requires SIWE authentication. The voter's weight is determined by their
+   * tier/role at the time of voting (or mock-determined in demo).
+   * Throws 403 if voting is not open, 404 if proposal not found.
+   */
+  castVote(proposalId: string, choice: VoteChoice): Promise<Vote>
+
+  // ── Admin mutations ───────────────────────────────────────────────────
+  /**
+   * Create a new governance proposal (admin only).
+   * Initially in 'draft' status; must call publishProposal() to activate.
+   */
+  createProposal(proposal: Omit<Proposal, 'id' | 'createdAt' | 'status' | 'communityId' | 'votesSummary' | 'totalWeight'>): Promise<Proposal>
+
+  /**
+   * Update a proposal (admin only, must be in draft or closed status).
+   */
+  updateProposal(id: string, updates: Partial<Omit<Proposal, 'id' | 'status' | 'proposer' | 'createdAt' | 'votesSummary' | 'totalWeight'>>): Promise<Proposal>
+
+  /**
+   * Publish a draft proposal, transitioning it to 'active' and opening voting.
+   * Admin only.
+   */
+  publishProposal(id: string): Promise<Proposal>
+
+  /**
+   * Close voting on an active proposal, transitioning to 'closed'.
+   * Admin only. Does not execute/resolve the outcome.
+   */
+  closeProposalVoting(id: string): Promise<Proposal>
+
+  /**
+   * Resolve a closed proposal by applying its outcome (e.g., update policy, add resource).
+   * Admin only. This is a notification method; actual state changes happen on the backend.
+   */
+  resolveProposal(id: string, outcome: string): Promise<Proposal>
+
+  /**
+   * Delete a draft proposal. Admin only.
+   */
+  deleteProposal(id: string): Promise<void>
+}
+
 // ── API Interface ─────────────────────────────────────────────────────────────
 
 /**
@@ -300,6 +467,22 @@ export interface MemberAccessApi {
   rejectConnectionRequest(targetAddress: string): Promise<void>
 }
 
+export interface RoleDistributionEntry {
+  role: Role
+  count: number
+}
+
+/**
+ * Analytics surface exposed on {@link AdminAccessApi}. Both LiveAccessApi
+ * and MockAccessApi implement this as a plain object of async methods
+ * (see lib/api/live.ts / lib/api/mock.ts's \`analytics\` field).
+ */
+export interface AnalyticsDataSource {
+  getMembershipTrend(signal?: AbortSignal): Promise<MemberGrowthDataPoint[]>
+  getRoleDistribution(signal?: AbortSignal): Promise<RoleDistributionEntry[]>
+  getAccessAttempts(signal?: AbortSignal): Promise<ResourceAccessCount[]>
+}
+
 /**
  * Authenticated admin queries and mutations.
  * These methods require a valid SIWE token context.
@@ -307,6 +490,8 @@ export interface MemberAccessApi {
 export interface AdminAccessApi {
   // ── Admin queries & mutations (require a valid SIWE token context) ────────
   listWebhookEvents(signal?: AbortSignal): Promise<WebhookEventLog[]>
+  /** Paginated/filterable variant of listWebhookEvents used by app/admin/events. */
+  listAdminEvents(params?: AdminEventFilterParams): Promise<Paginated<WebhookEvent>>
   /**
    * Subscribe to the admin webhook event stream.
    *
@@ -328,15 +513,31 @@ export interface AdminAccessApi {
   approveAction(id: string): Promise<void>
   rejectAction(id: string): Promise<void>
   updateApprovalConfig(config: ApprovalConfig): Promise<void>
-  
-  assignRole(address: string, role: Role): Promise<{ status: 'executed' | 'pending'; pendingActionId?: string }>
-  removeRole(address: string, role: Role): Promise<{ status: 'executed' | 'pending'; pendingActionId?: string }>
-  updatePolicy(policy: AccessPolicy): Promise<{ status: 'executed' | 'pending'; pendingActionId?: string }>
+
+  assignRole(address: string, role: Role): Promise<MutationResult>
+  removeRole(address: string, role: Role): Promise<MutationResult>
+  updatePolicy(policy: AccessPolicy): Promise<MutationResult>
 
   // ── Moderation Queue ──
   listReports(signal?: AbortSignal): Promise<ModerationReport[]>
   getReport(id: string, signal?: AbortSignal): Promise<ModerationReport | null>
   updateReportState(id: string, state: ModerationState, updates?: Partial<ModerationReport>): Promise<void>
+
+  // ── Governance (requires SIWE auth for voting/proposals) ──
+  listProposals(params?: { filter?: ProposalStatus | ProposalType; limit?: number; cursor?: string }, signal?: AbortSignal): Promise<Proposal[]>
+  getProposal(id: string, signal?: AbortSignal): Promise<Proposal | null>
+  getMemberVote(proposalId: string, signal?: AbortSignal): Promise<Vote | null>
+  listProposalVotes(proposalId: string, params?: { limit?: number; cursor?: string }, signal?: AbortSignal): Promise<Vote[]>
+  castVote(proposalId: string, choice: VoteChoice): Promise<Vote>
+  createProposal(proposal: Omit<Proposal, 'id' | 'createdAt' | 'status' | 'communityId' | 'votesSummary' | 'totalWeight'>): Promise<Proposal>
+  updateProposal(id: string, updates: Partial<Omit<Proposal, 'id' | 'status' | 'proposer' | 'createdAt' | 'votesSummary' | 'totalWeight'>>): Promise<Proposal>
+  publishProposal(id: string): Promise<Proposal>
+  closeProposalVoting(id: string): Promise<Proposal>
+  resolveProposal(id: string, outcome: string): Promise<Proposal>
+  deleteProposal(id: string): Promise<void>
+
+  // Analytics
+  analytics: AnalyticsDataSource
 }
 
 /**
diff --git a/test/mutation-queue.test.ts b/test/mutation-queue.test.ts
new file mode 100644
index 0000000..56f2a8e
--- /dev/null
+++ b/test/mutation-queue.test.ts
@@ -0,0 +1,119 @@
+import './setup-env'
+import { describe, test } from 'node:test'
+import * as assert from 'node:assert/strict'
+import {
+  createInMemoryQueueStorage,
+  createMutationQueue,
+  type QueuedMutation,
+} from '../lib/offline/mutation-queue'
+
+describe('mutation queue', () => {
+  test('enqueue persists a mutation with id, queuedAt, and retryCount 0', async () => {
+    const queue = createMutationQueue(createInMemoryQueueStorage())
+
+    const mutation = await queue.enqueue(
+      'assignRole',
+      { address: '0xabc', role: 'moderator' },
+      'guildpass-demo',
+    )
+
+    assert.ok(mutation.id)
+    assert.ok(mutation.queuedAt)
+    assert.equal(mutation.retryCount, 0)
+    assert.equal(mutation.type, 'assignRole')
+    assert.deepEqual(mutation.payload, { address: '0xabc', role: 'moderator' })
+    assert.equal(mutation.communitySlug, 'guildpass-demo')
+
+    assert.equal(await queue.count(), 1)
+  })
+
+  test('lists queued mutations in FIFO (oldest-first) order', async () => {
+    const queue = createMutationQueue(createInMemoryQueueStorage())
+
+    const first = await queue.enqueue('assignRole', { address: '0x1', role: 'member' }, 'demo')
+    const second = await queue.enqueue('removeRole', { address: '0x2', role: 'admin' }, 'demo')
+    const third = await queue.enqueue(
+      'updatePolicy',
+      { policy: { resourceId: 'alpha' } },
+      'demo',
+    )
+
+    const all = await queue.list()
+    assert.deepEqual(
+      all.map((m) => m.id),
+      [first.id, second.id, third.id],
+    )
+
+    const oldest = await queue.peek()
+    assert.equal(oldest?.id, first.id)
+  })
+
+  test('dequeue (remove) drops a mutation and advances the head of the queue', async () => {
+    const queue = createMutationQueue(createInMemoryQueueStorage())
+
+    const first = await queue.enqueue('assignRole', { address: '0x1', role: 'member' }, 'demo')
+    const second = await queue.enqueue('removeRole', { address: '0x2', role: 'admin' }, 'demo')
+
+    await queue.remove(first.id)
+
+    assert.equal(await queue.count(), 1)
+    const remaining = await queue.peek()
+    assert.equal(remaining?.id, second.id)
+  })
+
+  test('incrementRetryCount bumps retryCount and returns null for an unknown id', async () => {
+    const queue = createMutationQueue(createInMemoryQueueStorage())
+    const mutation = await queue.enqueue('assignRole', { address: '0x1', role: 'member' }, 'demo')
+
+    const once = await queue.incrementRetryCount(mutation.id)
+    assert.equal(once?.retryCount, 1)
+
+    const twice = await queue.incrementRetryCount(mutation.id)
+    assert.equal(twice?.retryCount, 2)
+
+    const missing = await queue.incrementRetryCount('does-not-exist')
+    assert.equal(missing, null)
+  })
+
+  test('survives a simulated page reload — a fresh queue instance over the same backing store sees prior entries', async () => {
+    const backingStore = new Map<string, QueuedMutation>()
+
+    const beforeReload = createMutationQueue(createInMemoryQueueStorage(backingStore))
+    await beforeReload.enqueue('assignRole', { address: '0xabc', role: 'admin' }, 'demo')
+    await beforeReload.enqueue('removeRole', { address: '0xdef', role: 'moderator' }, 'demo')
+
+    // Simulate a full page reload: a brand new queue object, constructed
+    // fresh, over the same durable backing store (IndexedDB in the browser;
+    // the same Map here stands in for "whatever survived the reload").
+    const afterReload = createMutationQueue(createInMemoryQueueStorage(backingStore))
+
+    const restored = await afterReload.list()
+    assert.equal(restored.length, 2)
+    const [firstEntry, secondEntry] = restored
+    assert.equal(firstEntry.type, 'assignRole')
+    assert.equal(secondEntry.type, 'removeRole')
+    if (firstEntry.type !== 'assignRole' || secondEntry.type !== 'removeRole') {
+      throw new Error('unexpected mutation type after reload')
+    }
+    assert.equal(firstEntry.payload.address, '0xabc')
+    assert.equal(secondEntry.payload.address, '0xdef')
+  })
+
+  test('subscribe notifies on enqueue and remove', async () => {
+    const queue = createMutationQueue(createInMemoryQueueStorage())
+    let notifications = 0
+    const unsubscribe = queue.subscribe(() => {
+      notifications += 1
+    })
+
+    const mutation = await queue.enqueue('assignRole', { address: '0x1', role: 'member' }, 'demo')
+    assert.equal(notifications, 1)
+
+    await queue.remove(mutation.id)
+    assert.equal(notifications, 2)
+
+    unsubscribe()
+    await queue.enqueue('assignRole', { address: '0x2', role: 'member' }, 'demo')
+    assert.equal(notifications, 2)
+  })
+})
diff --git a/test/mutation-replay.test.ts b/test/mutation-replay.test.ts
new file mode 100644
index 0000000..0afa885
--- /dev/null
+++ b/test/mutation-replay.test.ts
@@ -0,0 +1,186 @@
+import './setup-env'
+import { describe, test, beforeEach } from 'node:test'
+import * as assert from 'node:assert/strict'
+import { ApiError } from '../lib/api/errors'
+import { mutationQueue } from '../lib/offline/mutation-queue'
+import {
+  drainMutationQueue,
+  __resetMutationReplayStateForTests,
+  type MutationReplayApi,
+} from '../lib/offline/mutation-replay'
+import type { AccessPolicy } from '../lib/api/types'
+
+async function clearQueue(): Promise<void> {
+  for (const mutation of await mutationQueue.list()) {
+    await mutationQueue.remove(mutation.id)
+  }
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms))
+}
+
+describe('mutation replay (drain)', () => {
+  beforeEach(async () => {
+    await clearQueue()
+    __resetMutationReplayStateForTests()
+  })
+
+  test('replays queued mutations in FIFO order, one at a time', async () => {
+    const callOrder: string[] = []
+    const concurrentDuringCall: number[] = []
+    let inFlight = 0
+
+    const api: MutationReplayApi = {
+      async assignRole(address, role) {
+        inFlight += 1
+        concurrentDuringCall.push(inFlight)
+        callOrder.push(`assignRole:${address}:${role}`)
+        await sleep(5)
+        inFlight -= 1
+        return { status: 'executed' }
+      },
+      async removeRole(address, role) {
+        inFlight += 1
+        concurrentDuringCall.push(inFlight)
+        callOrder.push(`removeRole:${address}:${role}`)
+        await sleep(5)
+        inFlight -= 1
+        return { status: 'executed' }
+      },
+      async updatePolicy(policy) {
+        inFlight += 1
+        concurrentDuringCall.push(inFlight)
+        callOrder.push(`updatePolicy:${policy.resourceId}`)
+        await sleep(5)
+        inFlight -= 1
+        return { status: 'executed' }
+      },
+      async getPolicy() {
+        return null
+      },
+    }
+
+    await mutationQueue.enqueue('assignRole', { address: '0x1', role: 'member' }, 'demo')
+    await mutationQueue.enqueue('removeRole', { address: '0x2', role: 'moderator' }, 'demo')
+    await mutationQueue.enqueue('updatePolicy', { policy: { resourceId: 'alpha' } }, 'demo')
+
+    const outcome = await drainMutationQueue(() => api)
+
+    assert.deepEqual(callOrder, [
+      'assignRole:0x1:member',
+      'removeRole:0x2:moderator',
+      'updatePolicy:alpha',
+    ])
+    // Never more than one mutation executing at a time.
+    assert.deepEqual(concurrentDuringCall, [1, 1, 1])
+    assert.equal(outcome.kind, 'drained')
+    assert.equal(await mutationQueue.count(), 0)
+  })
+
+  test('a failure blocks the head of the queue — later items are not replayed out of order', async () => {
+    const callOrder: string[] = []
+    const api: MutationReplayApi = {
+      async assignRole(address) {
+        callOrder.push(`assignRole:${address}`)
+        throw new ApiError({ code: 'server_error', safeMessage: 'boom', retryable: true })
+      },
+      async removeRole(address) {
+        callOrder.push(`removeRole:${address}`)
+        return { status: 'executed' }
+      },
+      async updatePolicy() {
+        callOrder.push('updatePolicy')
+        return { status: 'executed' }
+      },
+      async getPolicy() {
+        return null
+      },
+    }
+
+    const first = await mutationQueue.enqueue(
+      'assignRole',
+      { address: '0x1', role: 'member' },
+      'demo',
+    )
+    await mutationQueue.enqueue('removeRole', { address: '0x2', role: 'moderator' }, 'demo')
+
+    const outcome = await drainMutationQueue(() => api)
+
+    // removeRole must never be attempted while assignRole is stuck at the head.
+    assert.deepEqual(callOrder, ['assignRole:0x1'])
+    assert.equal(outcome.kind, 'blocked')
+
+    const remaining = await mutationQueue.list()
+    assert.equal(remaining.length, 2)
+    assert.equal(remaining[0].id, first.id)
+    assert.equal(remaining[0].retryCount, 1)
+  })
+
+  test('a 409 on updatePolicy surfaces as a conflict and never discards the mutation', async () => {
+    const attemptedPolicy: AccessPolicy = { resourceId: 'alpha', minTier: 'pro', updatedAt: 't1' }
+    const currentPolicy: AccessPolicy = { resourceId: 'alpha', minTier: 'standard', updatedAt: 't2' }
+
+    const api: MutationReplayApi = {
+      async assignRole() {
+        return { status: 'executed' }
+      },
+      async removeRole() {
+        return { status: 'executed' }
+      },
+      async updatePolicy() {
+        throw new ApiError({ status: 409, code: 'conflict', safeMessage: 'conflict' })
+      },
+      async getPolicy() {
+        return currentPolicy
+      },
+    }
+
+    await mutationQueue.enqueue('updatePolicy', { policy: attemptedPolicy }, 'demo')
+
+    const outcome = await drainMutationQueue(() => api)
+
+    assert.equal(outcome.kind, 'conflict')
+    if (outcome.kind === 'conflict') {
+      assert.deepEqual(outcome.context.attemptedPolicy, attemptedPolicy)
+      assert.deepEqual(outcome.context.currentPolicy, currentPolicy)
+    }
+
+    // Never silently discarded or overwritten — still queued for the admin.
+    assert.equal(await mutationQueue.count(), 1)
+  })
+
+  test('prevents concurrent drains — a second call while one is in flight is a no-op', async () => {
+    let callCount = 0
+    const api: MutationReplayApi = {
+      async assignRole() {
+        callCount += 1
+        await sleep(20)
+        return { status: 'executed' }
+      },
+      async removeRole() {
+        return { status: 'executed' }
+      },
+      async updatePolicy() {
+        return { status: 'executed' }
+      },
+      async getPolicy() {
+        return null
+      },
+    }
+
+    await mutationQueue.enqueue('assignRole', { address: '0x1', role: 'member' }, 'demo')
+
+    // Deliberately not awaited — drainMutationQueue sets its mutex flag
+    // synchronously before its first `await`, so the second call below is
+    // guaranteed to observe "already draining" without needing a timer.
+    const firstDrain = drainMutationQueue(() => api)
+    const secondOutcome = await drainMutationQueue(() => api)
+
+    assert.equal(secondOutcome.kind, 'skipped')
+
+    const firstOutcome = await firstDrain
+    assert.equal(firstOutcome.kind, 'drained')
+    assert.equal(callCount, 1)
+  })
+})
diff --git a/test/policy-conflict-replay.test.ts b/test/policy-conflict-replay.test.ts
new file mode 100644
index 0000000..f3561a5
--- /dev/null
+++ b/test/policy-conflict-replay.test.ts
@@ -0,0 +1,79 @@
+import './setup-env'
+import { describe, test, beforeEach } from 'node:test'
+import * as assert from 'node:assert/strict'
+import { MockAccessApi, resetMockData } from '../lib/api/mock'
+import { withOfflineMutationQueue } from '../lib/api/offline-mutations'
+import { mutationQueue } from '../lib/offline/mutation-queue'
+import { drainMutationQueue, __resetMutationReplayStateForTests } from '../lib/offline/mutation-replay'
+import { NetworkError } from '../lib/api/errors'
+import type { AccessApi, AccessPolicy } from '../lib/api/types'
+
+async function clearQueue(): Promise<void> {
+  for (const mutation of await mutationQueue.list()) {
+    await mutationQueue.remove(mutation.id)
+  }
+}
+
+describe('offline policy conflict replay (end-to-end)', () => {
+  beforeEach(async () => {
+    await resetMockData()
+    await clearQueue()
+    __resetMutationReplayStateForTests()
+  })
+
+  test('offline -> queued -> reconnect -> 409 -> conflict, preserving attempted vs. current context', async () => {
+    const communitySlug = 'guildpass-demo'
+    const api = new MockAccessApi('0xadmin', communitySlug)
+
+    // Baseline: create the policy so there's a real updatedAt to version
+    // against (mirrors docs/POLICY_CONCURRENCY.md's optimistic-concurrency
+    // scheme — updatedAt IS the version token).
+    await api.updatePolicy({ resourceId: 'alpha', minTier: 'standard' })
+    const loaded = await api.getPolicy('alpha')
+    assert.ok(loaded?.updatedAt)
+
+    // The admin's attempted change, built from the version they had loaded
+    // before going offline.
+    const attemptedPolicy: AccessPolicy = {
+      resourceId: 'alpha',
+      minTier: 'pro',
+      updatedAt: loaded!.updatedAt,
+    }
+
+    // 1. OFFLINE — the network call fails; withOfflineMutationQueue queues
+    // the mutation instead of throwing.
+    const offlineApi = {
+      updatePolicy: async () => {
+        throw new NetworkError()
+      },
+    } as unknown as AccessApi
+    const result = await withOfflineMutationQueue(offlineApi, communitySlug).updatePolicy(
+      attemptedPolicy,
+    )
+    assert.equal(result.status, 'queued')
+    assert.equal(await mutationQueue.count(), 1)
+
+    // 2. While offline, another admin changes the policy — the server's
+    // updatedAt moves on without our queued edit knowing about it.
+    await api.updatePolicy({ resourceId: 'alpha', minTier: 'standard' })
+    const serverNow = await api.getPolicy('alpha')
+    assert.notEqual(serverNow?.updatedAt, attemptedPolicy.updatedAt)
+
+    // 3. RECONNECT — replay against the real API. The stale updatedAt in
+    // our queued mutation no longer matches the server's, so it 409s.
+    const outcome = await drainMutationQueue(() => api)
+
+    assert.equal(outcome.kind, 'conflict')
+    if (outcome.kind === 'conflict') {
+      // PolicyConflictDialog must be able to show exactly what the admin
+      // tried to save...
+      assert.deepEqual(outcome.context.attemptedPolicy, attemptedPolicy)
+      // ...compared against exactly what's actually on the server now.
+      assert.deepEqual(outcome.context.currentPolicy, serverNow)
+    }
+
+    // Never silently applied or dropped — stays queued until the admin
+    // resolves it via the conflict dialog.
+    assert.equal(await mutationQueue.count(), 1)
+  })
+})
diff --git a/test/tsconfig.json b/test/tsconfig.json
index 64de19e..2fda9e9 100644
--- a/test/tsconfig.json
+++ b/test/tsconfig.json
@@ -79,6 +79,14 @@
     "../lib/integration/resilientCall.ts",
     "../lib/hooks/*.ts",
     "../lib/members/*.ts",
-    "../components/admin/*.tsx"
+    "../components/admin/*.tsx",
+    "../lib/offline/mutation-queue.ts",
+    "../lib/offline/mutation-replay.ts",
+    "../lib/offline/use-mutation-queue-status.ts",
+    "../lib/offline/use-sync-status.ts",
+    "../lib/api/offline-mutations.ts",
+    "../lib/api/policy-conflict.ts",
+    "../components/offline/mutation-queue-sync.tsx",
+    "../components/ui/sync-status-banner.tsx"
   ]
 }