diff --git a/frontend/app/[locale]/dashboard/group/[id]/GroupClient.tsx b/frontend/app/[locale]/dashboard/group/[id]/GroupClient.tsx
index ca9a2a7..a33912e 100644
--- a/frontend/app/[locale]/dashboard/group/[id]/GroupClient.tsx
+++ b/frontend/app/[locale]/dashboard/group/[id]/GroupClient.tsx
@@ -8,6 +8,7 @@ import { GroupActivity } from "@/components/group/group-activity"
 import { GroupActions } from "@/components/group/group-actions"
 import { RotationalTimelineContainer } from "@/components/group/rotational-timeline-container"
 import { PoolChat } from "@/components/group/pool-chat"
+import { DisputesPanel } from "@/components/disputes/disputes-panel"
 import { Button } from "@/components/ui/button"
 import { ArrowLeft } from "lucide-react"
 import Link from "next/link"
@@ -136,6 +137,15 @@ export default function GroupClient({ params }: { params: Promise<{ id: string }
             <GroupMembers groupId={id} contractAddress={cacheKey} />
           </div>
         </div>
+
+        {/* Dispute resolution — full width so cards have room for evidence links */}
+        <section className="mt-6">
+          <DisputesPanel
+            poolId={pool.id}
+            memberAddresses={(pool.pool_members ?? []).map((m) => m.member_address)}
+            poolAdmin={poolAdmin}
+          />
+        </section>
       </main>
     </div>
   )
diff --git a/frontend/app/api/disputes/[id]/resolve/route.ts b/frontend/app/api/disputes/[id]/resolve/route.ts
new file mode 100644
index 0000000..4dc44c5
--- /dev/null
+++ b/frontend/app/api/disputes/[id]/resolve/route.ts
@@ -0,0 +1,90 @@
+/**
+ * /api/disputes/[id]/resolve — Pool admin resolution (issue #208)
+ *
+ * POST { admin_address, outcome: "upheld" | "dismissed", resolution }
+ *
+ * Lets the pool creator close an active dispute directly — used for tie
+ * votes, expired windows that should still get a verdict, or urgent cases.
+ * Requires a written resolution note and logs to pool_activity.
+ */
+
+import { getAdminClient } from "@/lib/supabase-admin"
+import { NextRequest, NextResponse } from "next/server"
+import { writeLimiter } from "@/lib/rate-limit"
+
+export async function POST(req: NextRequest, ctx: { params: Promise<{ id: string }> }) {
+  const limited = writeLimiter(req)
+  if (limited) return limited
+
+  const { id } = await ctx.params
+
+  let body: { admin_address?: string; outcome?: string; resolution?: string }
+  try {
+    body = await req.json()
+  } catch {
+    return NextResponse.json({ error: "Invalid JSON" }, { status: 400 })
+  }
+
+  const adminAddress =
+    typeof body.admin_address === "string" ? body.admin_address.toLowerCase() : ""
+  const outcome = body.outcome
+  const resolution = typeof body.resolution === "string" ? body.resolution.trim() : ""
+
+  if (!id || !adminAddress) {
+    return NextResponse.json(
+      { error: "dispute id and admin_address are required" },
+      { status: 400 }
+    )
+  }
+  if (outcome !== "upheld" && outcome !== "dismissed") {
+    return NextResponse.json({ error: 'outcome must be "upheld" or "dismissed"' }, { status: 422 })
+  }
+  if (!resolution) {
+    return NextResponse.json({ error: "resolution note is required" }, { status: 422 })
+  }
+
+  const admin = getAdminClient()
+  const { data: dispute } = await admin.from("disputes").select("*").eq("id", id).maybeSingle()
+  if (!dispute) return NextResponse.json({ error: "Dispute not found" }, { status: 404 })
+
+  const { data: pool } = await admin
+    .from("pools")
+    .select("creator_address")
+    .eq("id", dispute.pool_id)
+    .maybeSingle()
+  if (!pool || pool.creator_address?.toLowerCase() !== adminAddress) {
+    return NextResponse.json({ error: "Only the pool admin can resolve disputes" }, { status: 403 })
+  }
+
+  if (!["open", "voting"].includes(dispute.status)) {
+    return NextResponse.json({ error: `Dispute is already ${dispute.status}` }, { status: 409 })
+  }
+
+  const resolvedStatus = outcome === "upheld" ? "resolved_upheld" : "resolved_dismissed"
+
+  const { data: updated, error: updateError } = await admin
+    .from("disputes")
+    .update({
+      status: resolvedStatus,
+      resolution,
+      resolved_by: adminAddress,
+      resolved_at: new Date().toISOString(),
+    })
+    .eq("id", id)
+    .select("*")
+    .single()
+
+  if (updateError) return NextResponse.json({ error: updateError.message }, { status: 500 })
+
+  await admin.from("pool_activity").insert({
+    pool_id: dispute.pool_id,
+    activity_type: "dispute_resolved",
+    user_address: adminAddress,
+    description:
+      outcome === "upheld"
+        ? `Dispute upheld by admin: ${resolution.slice(0, 140)}`
+        : `Dispute dismissed by admin: ${resolution.slice(0, 140)}`,
+  })
+
+  return NextResponse.json({ dispute: updated })
+}
diff --git a/frontend/app/api/disputes/[id]/vote/route.ts b/frontend/app/api/disputes/[id]/vote/route.ts
new file mode 100644
index 0000000..8d0c90d
--- /dev/null
+++ b/frontend/app/api/disputes/[id]/vote/route.ts
@@ -0,0 +1,136 @@
+/**
+ * /api/disputes/[id]/vote — Cast a member vote on a dispute (issue #208)
+ *
+ * POST { voter_address, vote: boolean }
+ *
+ * Rules:
+ *  - Voter must be a pool member and cannot be the filer or the target.
+ *  - One vote per wallet per dispute (enforced by the dispute_votes PK).
+ *  - The dispute must still be open/voting and unexpired.
+ *  - When one side reaches half the pool (rounded up), the dispute is
+ *    auto-resolved and logged to pool_activity.
+ */
+
+import { getAdminClient } from "@/lib/supabase-admin"
+import { NextRequest, NextResponse } from "next/server"
+import { writeLimiter } from "@/lib/rate-limit"
+import { canVoteOnDispute, votesNeededToResolve } from "@/lib/disputes"
+import type { Database } from "@/lib/supabase"
+
+type DisputeRow = Database["public"]["Tables"]["disputes"]["Row"]
+type DisputeUpdate = Database["public"]["Tables"]["disputes"]["Update"]
+
+const UNIQUE_VIOLATION = "23505"
+
+export async function POST(req: NextRequest, ctx: { params: Promise<{ id: string }> }) {
+  const limited = writeLimiter(req)
+  if (limited) return limited
+
+  const { id } = await ctx.params
+
+  let body: { voter_address?: string; vote?: boolean }
+  try {
+    body = await req.json()
+  } catch {
+    return NextResponse.json({ error: "Invalid JSON" }, { status: 400 })
+  }
+
+  const voter = typeof body.voter_address === "string" ? body.voter_address.toLowerCase() : ""
+  const vote = body.vote
+  if (!id || !voter || typeof vote !== "boolean") {
+    return NextResponse.json(
+      { error: "dispute id, voter_address and boolean vote are required" },
+      { status: 400 }
+    )
+  }
+
+  const admin = getAdminClient()
+  const { data: dispute } = await admin
+    .from("disputes")
+    .select("*")
+    .eq("id", id)
+    .maybeSingle<DisputeRow>()
+  if (!dispute) return NextResponse.json({ error: "Dispute not found" }, { status: 404 })
+
+  if (!["open", "voting"].includes(dispute.status)) {
+    return NextResponse.json({ error: `Dispute is already ${dispute.status}` }, { status: 409 })
+  }
+  if (new Date(dispute.expires_at).getTime() <= Date.now()) {
+    return NextResponse.json({ error: "Voting window has expired" }, { status: 409 })
+  }
+
+  // Server-side membership check (UI gating is not security).
+  const { data: membership } = await admin
+    .from("pool_members")
+    .select("id")
+    .eq("pool_id", dispute.pool_id)
+    .eq("member_address", voter)
+    .maybeSingle()
+  if (!membership) {
+    return NextResponse.json({ error: "Not a member of this pool" }, { status: 403 })
+  }
+
+  if (!canVoteOnDispute(voter, dispute, false)) {
+    return NextResponse.json({ error: "Filers and dispute targets cannot vote" }, { status: 403 })
+  }
+
+  const { error: insertError } = await admin.from("dispute_votes").insert({
+    dispute_id: id,
+    voter_address: voter,
+    vote,
+  })
+  if (insertError) {
+    if (insertError.code === UNIQUE_VIOLATION) {
+      return NextResponse.json({ error: "You have already voted on this dispute" }, { status: 409 })
+    }
+    return NextResponse.json({ error: insertError.message }, { status: 500 })
+  }
+
+  const forCount = dispute.votes_for + (vote ? 1 : 0)
+  const againstCount = dispute.votes_against + (vote ? 0 : 1)
+
+  // Majority threshold: half of current members, rounded up.
+  const { count: memberCount } = await admin
+    .from("pool_members")
+    .select("id", { count: "exact", head: true })
+    .eq("pool_id", dispute.pool_id)
+  const needed = votesNeededToResolve(memberCount ?? 0)
+
+  let resolvedStatus: DisputeRow["status"] | null = null
+  if (needed > 0 && forCount >= needed) resolvedStatus = "resolved_upheld"
+  else if (needed > 0 && againstCount >= needed) resolvedStatus = "resolved_dismissed"
+
+  const update: DisputeUpdate = {
+    votes_for: forCount,
+    votes_against: againstCount,
+  }
+  if (dispute.status === "open") update.status = "voting"
+  if (resolvedStatus) {
+    update.status = resolvedStatus
+    update.resolved_by = voter
+    update.resolved_at = new Date().toISOString()
+  }
+
+  const { data: updated, error: updateError } = await admin
+    .from("disputes")
+    .update(update)
+    .eq("id", id)
+    .select("*")
+    .single<DisputeRow>()
+
+  if (updateError) return NextResponse.json({ error: updateError.message }, { status: 500 })
+
+  if (resolvedStatus) {
+    await admin.from("pool_activity").insert({
+      pool_id: dispute.pool_id,
+      activity_type: "dispute_resolved",
+      user_address: voter,
+      description:
+        resolvedStatus === "resolved_upheld"
+          ? "Dispute upheld by community vote"
+          : "Dispute dismissed by community vote",
+    })
+  }
+
+  return NextResponse.json({ dispute: updated })
+}
diff --git a/frontend/app/api/disputes/expire/route.ts b/frontend/app/api/disputes/expire/route.ts
new file mode 100644
index 0000000..191d97b
--- /dev/null
+++ b/frontend/app/api/disputes/expire/route.ts
@@ -0,0 +1,30 @@
+/**
+ * /api/disputes/expire — Cron job: expire stale disputes (issue #208)
+ *
+ * POST (Bearer CRON_SECRET) — flips open/voting disputes whose 72h window
+ * has elapsed to "expired". Scheduled like the other Vercel cron endpoints.
+ */
+
+import { getAdminClient } from "@/lib/supabase-admin"
+import { NextResponse } from "next/server"
+
+export async function POST(req: Request) {
+  if (!process.env.CRON_SECRET) {
+    return NextResponse.json({ error: "CRON_SECRET is not configured" }, { status: 500 })
+  }
+  const authHeader = req.headers.get("authorization")
+  if (authHeader !== `Bearer ${process.env.CRON_SECRET}`) {
+    return NextResponse.json({ error: "Unauthorized" }, { status: 401 })
+  }
+
+  const { data, error } = await getAdminClient()
+    .from("disputes")
+    .update({ status: "expired" })
+    .in("status", ["open", "voting"])
+    .lt("expires_at", new Date().toISOString())
+    .select("id")
+
+  if (error) return NextResponse.json({ error: error.message }, { status: 500 })
+
+  return NextResponse.json({ expired: data?.length ?? 0 })
+}
diff --git a/frontend/app/api/disputes/route.ts b/frontend/app/api/disputes/route.ts
new file mode 100644
index 0000000..ccb2879
--- /dev/null
+++ b/frontend/app/api/disputes/route.ts
@@ -0,0 +1,207 @@
+/**
+ * /api/disputes — Pool dispute resolution API (issue #208)
+ *
+ * GET  /api/disputes?pool_id=<id>[&status=open,voting]
+ *   Lists disputes for a pool, newest first.
+ *
+ * POST /api/disputes
+ *   { pool_id, filer_address, dispute_type, description,
+ *     target_address?, evidence_urls? }
+ *   Files a new dispute. Members only; one active dispute per filer per pool;
+ *   auto-expires after DISPUTE_EXPIRY_HOURS.
+ */
+
+import { getAdminClient } from "@/lib/supabase-admin"
+import { NextRequest, NextResponse } from "next/server"
+import { readLimiter, writeLimiter } from "@/lib/rate-limit"
+import {
+  DISPUTE_DESCRIPTION_MAX_LENGTH,
+  DISPUTE_EXPIRY_HOURS,
+  DISPUTE_MAX_EVIDENCE_URLS,
+  isDisputeType,
+  validateEvidenceUrls,
+} from "@/lib/disputes"
+import type { DisputeStatus } from "@/lib/disputes"
+
+const ACTIVE_STATUSES = ["open", "voting"] as const
+
+interface DisputeRow {
+  id: string
+  pool_id: string
+  filer_address: string
+  target_address: string | null
+  dispute_type: string
+  description: string
+  evidence_urls: string[]
+  status: string
+  resolution: string | null
+  votes_for: number
+  votes_against: number
+  resolved_by: string | null
+  resolved_at: string | null
+  created_at: string
+  expires_at: string
+}
+
+async function isMember(poolId: string, wallet: string): Promise<boolean> {
+  const { data } = await getAdminClient()
+    .from("pool_members")
+    .select("id")
+    .eq("pool_id", poolId)
+    .eq("member_address", wallet.toLowerCase())
+    .maybeSingle()
+  return data !== null
+}
+
+// ── GET ───────────────────────────────────────────────────────────────────────
+
+export async function GET(req: NextRequest) {
+  const limited = readLimiter(req)
+  if (limited) return limited
+
+  const poolId = req.nextUrl.searchParams.get("pool_id")
+  const statusParam = req.nextUrl.searchParams.get("status")
+  if (!poolId) return NextResponse.json({ error: "pool_id required" }, { status: 400 })
+
+  let query = getAdminClient()
+    .from("disputes")
+    .select("*")
+    .eq("pool_id", poolId)
+    .order("created_at", { ascending: false })
+    .limit(100)
+
+  if (statusParam) {
+    const VALID_STATUSES: readonly DisputeStatus[] = [
+      "open",
+      "voting",
+      "resolved_upheld",
+      "resolved_dismissed",
+      "expired",
+    ]
+    const statuses = statusParam
+      .split(",")
+      .map((s) => s.trim())
+      .filter((s): s is DisputeStatus => (VALID_STATUSES as readonly string[]).includes(s))
+    if (statuses.length > 0) query = query.in("status", statuses)
+  }
+
+  const { data, error } = await query
+  if (error) return NextResponse.json({ error: error.message }, { status: 500 })
+
+  return NextResponse.json({ disputes: data ?? [] })
+}
+
+// ── POST ──────────────────────────────────────────────────────────────────────
+
+export async function POST(req: NextRequest) {
+  const limited = writeLimiter(req)
+  if (limited) return limited
+
+  let body: Record<string, unknown>
+  try {
+    body = await req.json()
+  } catch {
+    return NextResponse.json({ error: "Invalid JSON" }, { status: 400 })
+  }
+
+  const poolId = typeof body.pool_id === "string" ? body.pool_id : ""
+  const filer = typeof body.filer_address === "string" ? body.filer_address.toLowerCase() : ""
+  const target =
+    typeof body.target_address === "string" && body.target_address.trim().length > 0
+      ? body.target_address.trim().toLowerCase()
+      : null
+  const disputeType = body.dispute_type
+  const description = typeof body.description === "string" ? body.description.trim() : ""
+
+  if (!poolId || !filer) {
+    return NextResponse.json({ error: "pool_id and filer_address are required" }, { status: 400 })
+  }
+  if (!isDisputeType(disputeType)) {
+    return NextResponse.json(
+      {
+        error:
+          "dispute_type must be one of: missed_deposit, unfair_penalty, admin_abuse, member_misconduct, other",
+      },
+      { status: 422 }
+    )
+  }
+  if (!description || description.length > DISPUTE_DESCRIPTION_MAX_LENGTH) {
+    return NextResponse.json(
+      { error: `description is required (max ${DISPUTE_DESCRIPTION_MAX_LENGTH} characters)` },
+      { status: 422 }
+    )
+  }
+
+  const evidence = validateEvidenceUrls(body.evidence_urls)
+  if (evidence.invalid.length > 0) {
+    return NextResponse.json(
+      { error: "evidence_urls must be valid http(s) URLs", invalid: evidence.invalid },
+      { status: 422 }
+    )
+  }
+
+  // Filer must be a pool member; an identified target must be too.
+  const filerIsMember = await isMember(poolId, filer)
+  if (!filerIsMember) {
+    return NextResponse.json({ error: "Not a member of this pool" }, { status: 403 })
+  }
+  if (target && target !== filer) {
+    const admin = getAdminClient()
+    const [targetIsMember, { data: pool }] = await Promise.all([
+      isMember(poolId, target),
+      admin.from("pools").select("creator_address").eq("id", poolId).maybeSingle(),
+    ])
+    const isAdmin = pool?.creator_address?.toLowerCase() === target
+    if (!targetIsMember && !isAdmin) {
+      return NextResponse.json(
+        { error: "Target address is not a pool participant" },
+        { status: 422 }
+      )
+    }
+  }
+
+  // One active dispute per filer per pool keeps the queue focused.
+  const { data: existing } = await getAdminClient()
+    .from("disputes")
+    .select("id")
+    .eq("pool_id", poolId)
+    .eq("filer_address", filer)
+    .in("status", ACTIVE_STATUSES)
+    .maybeSingle()
+  if (existing) {
+    return NextResponse.json(
+      { error: "You already have an active dispute in this pool" },
+      { status: 409 }
+    )
+  }
+
+  const expiresAt = new Date(Date.now() + DISPUTE_EXPIRY_HOURS * 60 * 60 * 1000).toISOString()
+
+  const { data, error } = await getAdminClient()
+    .from("disputes")
+    .insert({
+      pool_id: poolId,
+      filer_address: filer,
+      target_address: target,
+      dispute_type: disputeType,
+      description,
+      evidence_urls: evidence.valid.slice(0, DISPUTE_MAX_EVIDENCE_URLS),
+      status: "open",
+      expires_at: expiresAt,
+    })
+    .select("*")
+    .single<DisputeRow>()
+
+  if (error) return NextResponse.json({ error: error.message }, { status: 500 })
+
+  await getAdminClient()
+    .from("pool_activity")
+    .insert({
+      pool_id: poolId,
+      activity_type: "dispute_filed",
+      user_address: filer,
+      description: `Dispute filed (${disputeType})`,
+    })
+
+  return NextResponse.json({ dispute: data }, { status: 201 })
+}
diff --git a/frontend/components/disputes/dispute-card.tsx b/frontend/components/disputes/dispute-card.tsx
new file mode 100644
index 0000000..1f8debe
--- /dev/null
+++ b/frontend/components/disputes/dispute-card.tsx
@@ -0,0 +1,197 @@
+"use client"
+
+/**
+ * DisputeCard — single dispute row for the pool disputes panel (issue #208)
+ * Shows status badge, counts, description, evidence links, and vote buttons
+ * for eligible voters. Resolution notes appear once resolved.
+ */
+
+import { useState } from "react"
+import { useTranslations } from "next-intl"
+import { AlertTriangle, ExternalLink, Gavel, Scale } from "lucide-react"
+import { Badge } from "@/components/ui/badge"
+import { Button } from "@/components/ui/button"
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle,
+} from "@/components/ui/dialog"
+import { Textarea } from "@/components/ui/textarea"
+import type { DisputeRecord } from "@/lib/disputes"
+
+const STATUS_STYLES: Record<string, string> = {
+  open: "bg-blue-500/15 text-blue-600 dark:text-blue-400",
+  voting: "bg-blue-500/15 text-blue-600 dark:text-blue-400",
+  resolved_upheld: "bg-green-500/15 text-green-600 dark:text-green-400",
+  resolved_dismissed: "bg-gray-500/15 text-gray-600 dark:text-gray-400",
+  expired: "bg-orange-500/15 text-orange-600 dark:text-orange-400",
+}
+
+interface DisputeCardProps {
+  dispute: DisputeRecord
+  viewerAddress: string | null
+  isAdmin: boolean
+  totalMembers: number
+  onVote: (disputeId: string, inFavor: boolean) => void
+  onResolve: (disputeId: string, outcome: "upheld" | "dismissed", resolution: string) => void
+}
+
+export function DisputeCard({
+  dispute,
+  viewerAddress,
+  isAdmin,
+  totalMembers,
+  onVote,
+  onResolve,
+}: DisputeCardProps) {
+  const t = useTranslations("group.disputes")
+  const [resolveOpen, setResolveOpen] = useState(false)
+  const [resolutionDraft, setResolutionDraft] = useState("")
+
+  const viewer = viewerAddress?.toLowerCase() ?? null
+  const isActive = dispute.status === "open" || dispute.status === "voting"
+  const isExpired = new Date(dispute.expires_at).getTime() <= Date.now()
+
+  const isFiler = viewer === dispute.filer_address.toLowerCase()
+  const isTarget = !!dispute.target_address && viewer === dispute.target_address.toLowerCase()
+  const canVote = isActive && !isExpired && !!viewer && !isFiler && !isTarget
+
+  const needed = Math.ceil(totalMembers / 2)
+  const totalVotes = dispute.votes_for + dispute.votes_against
+
+  return (
+    <div className="rounded-lg border p-4 space-y-3">
+      <div className="flex flex-wrap items-center gap-2">
+        <Badge className={STATUS_STYLES[dispute.status] ?? ""}>
+          {t(`status.${dispute.status}`)}
+        </Badge>
+        <Badge variant="outline">{t(`types.${dispute.dispute_type}`)}</Badge>
+        {isActive && !isExpired && (
+          <span className="text-xs text-muted-foreground">
+            {t("expiresIn", { time: formatRemaining(dispute.expires_at) })}
+          </span>
+        )}
+      </div>
+
+      <p className="text-sm whitespace-pre-wrap break-words">{dispute.description}</p>
+
+      {(dispute.target_address || dispute.evidence_urls.length > 0) && (
+        <div className="text-xs text-muted-foreground space-y-1">
+          {dispute.target_address && (
+            <p>
+              <span className="font-medium">{t("against")}:</span>{" "}
+              <span className="font-mono">{shorten(dispute.target_address)}</span>
+            </p>
+          )}
+          {dispute.evidence_urls.map((url) => (
+            <a
+              key={url}
+              href={url}
+              target="_blank"
+              rel="noopener noreferrer"
+              className="flex items-center gap-1 text-primary hover:underline break-all"
+            >
+              <ExternalLink className="h-3 w-3 shrink-0" />
+              {url}
+            </a>
+          ))}
+        </div>
+      )}
+
+      {(dispute.status === "resolved_upheld" || dispute.status === "resolved_dismissed") &&
+        dispute.resolution && (
+          <div className="rounded-md bg-muted/50 p-3 text-xs">
+            <p className="font-medium mb-1">{t("resolutionNote")}</p>
+            <p className="whitespace-pre-wrap break-words">{dispute.resolution}</p>
+          </div>
+        )}
+
+      <div className="flex flex-wrap items-center justify-between gap-3 pt-1 border-t">
+        <div className="text-xs text-muted-foreground flex items-center gap-2">
+          <Scale className="h-3.5 w-3.5" />
+          {t("voteCounts", { for: dispute.votes_for, against: dispute.votes_against, needed })}
+          {isActive && !isExpired && (
+            <span className="opacity-70">({t("votesCast", { count: totalVotes })})</span>
+          )}
+        </div>
+
+        <div className="flex items-center gap-2">
+          {canVote && (
+            <>
+              <Button size="sm" variant="outline" onClick={() => onVote(dispute.id, false)}>
+                {t("voteDismiss")}
+              </Button>
+              <Button size="sm" onClick={() => onVote(dispute.id, true)}>
+                {t("voteUphold")}
+              </Button>
+            </>
+          )}
+          {isAdmin && isActive && (
+            <Button size="sm" variant="secondary" onClick={() => setResolveOpen(true)}>
+              <Gavel className="mr-1 h-3.5 w-3.5" />
+              {t("resolve")}
+            </Button>
+          )}
+        </div>
+      </div>
+
+      <Dialog open={resolveOpen} onOpenChange={setResolveOpen}>
+        <DialogContent>
+          <DialogHeader>
+            <DialogTitle className="flex items-center gap-2">
+              <AlertTriangle className="h-4 w-4 text-orange-500" />
+              {t("resolveTitle")}
+            </DialogTitle>
+            <DialogDescription>{t("resolveDescription")}</DialogDescription>
+          </DialogHeader>
+          <Textarea
+            value={resolutionDraft}
+            onChange={(e) => setResolutionDraft(e.target.value)}
+            placeholder={t("resolvePlaceholder")}
+            rows={3}
+          />
+          <DialogFooter className="gap-2 sm:gap-0">
+            <Button
+              variant="outline"
+              disabled={!resolutionDraft.trim()}
+              onClick={() => {
+                onResolve(dispute.id, "dismissed", resolutionDraft.trim())
+                setResolutionDraft("")
+                setResolveOpen(false)
+              }}
+            >
+              {t("dismissDispute")}
+            </Button>
+            <Button
+              disabled={!resolutionDraft.trim()}
+              onClick={() => {
+                onResolve(dispute.id, "upheld", resolutionDraft.trim())
+                setResolutionDraft("")
+                setResolveOpen(false)
+              }}
+            >
+              {t("upholdDispute")}
+            </Button>
+          </DialogFooter>
+        </DialogContent>
+      </Dialog>
+    </div>
+  )
+}
+
+function formatRemaining(expiresAtIso: string): string {
+  const diffMs = new Date(expiresAtIso).getTime() - Date.now()
+  if (diffMs <= 0) return "0m"
+  const minutes = Math.floor(diffMs / 60_000)
+  if (minutes < 60) return `${minutes}m`
+  const hours = Math.floor(minutes / 60)
+  if (hours < 24) return `${hours}h ${String(minutes % 60).padStart(2, "0")}m`
+  return `${Math.floor(hours / 24)}d ${String(hours % 24).padStart(2, "0")}h`
+}
+
+function shorten(address: string): string {
+  return address.length > 12 ? `${address.slice(0, 6)}…${address.slice(-4)}` : address
+}
diff --git a/frontend/components/disputes/disputes-panel.tsx b/frontend/components/disputes/disputes-panel.tsx
new file mode 100644
index 0000000..cf22e85
--- /dev/null
+++ b/frontend/components/disputes/disputes-panel.tsx
@@ -0,0 +1,105 @@
+"use client"
+
+/**
+ * DisputesPanel — pool disputes feed (issue #208).
+ * Composition root: loads disputes via useDisputes, renders the file-dispute
+ * dialog (members only) and the dispute cards. Admin actions appear for the
+ * pool creator. Rendered full-width below the group grid in GroupClient.
+ */
+
+import { useMemo } from "react"
+import { useTranslations } from "next-intl"
+import { Gavel } from "lucide-react"
+import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card"
+import { Skeleton } from "@/components/ui/skeleton"
+import { useDisputes } from "@/hooks/useDisputes"
+import { useStellar } from "@/components/web3-provider"
+import { DisputeCard } from "./dispute-card"
+import { FileDisputeDialog } from "./file-dispute-dialog"
+
+interface DisputesPanelProps {
+  poolId: string
+  memberAddresses: string[]
+  /** Pool creator address — gets the admin resolve buttons. */
+  poolAdmin: string | null
+}
+
+export function DisputesPanel({ poolId, memberAddresses, poolAdmin }: DisputesPanelProps) {
+  const t = useTranslations("group.disputes")
+  const { address } = useStellar()
+
+  const { disputes, loading, error, refresh, fileDispute, voteOnDispute, resolveDispute } =
+    useDisputes(poolId)
+
+  const isAdmin = useMemo(
+    () => !!address && !!poolAdmin && address.toLowerCase() === poolAdmin.toLowerCase(),
+    [address, poolAdmin]
+  )
+  const isMember = useMemo(
+    () => !!address && memberAddresses.some((m) => m.toLowerCase() === address.toLowerCase()),
+    [address, memberAddresses]
+  )
+
+  return (
+    <Card>
+      <CardHeader className="flex flex-row items-center justify-between space-y-0">
+        <CardTitle className="flex items-center gap-2 text-base font-semibold">
+          <Gavel className="h-4 w-4" />
+          {t("title")}
+        </CardTitle>
+        <FileDisputeDialog
+          disabled={!isMember}
+          memberAddresses={memberAddresses.filter(
+            (m) => !address || m.toLowerCase() !== address.toLowerCase()
+          )}
+          submitting={loading}
+          onSubmit={async ({ disputeType, description, targetAddress, evidenceUrls }) =>
+            !!address &&
+            (await fileDispute({
+              filerAddress: address,
+              disputeType,
+              description,
+              targetAddress,
+              evidenceUrls,
+            }))
+          }
+        />
+      </CardHeader>
+      <CardContent className="space-y-3">
+        {error && (
+          <div className="flex items-center justify-between gap-2 rounded-md bg-destructive/10 p-3 text-sm text-destructive">
+            <span>{error}</span>
+            <button className="underline" onClick={() => void refresh()}>
+              {t("retry")}
+            </button>
+          </div>
+        )}
+
+        {loading && disputes.length === 0 ? (
+          <>
+            <Skeleton className="h-28 w-full" />
+            <Skeleton className="h-28 w-full" />
+          </>
+        ) : disputes.length === 0 ? (
+          <p className="py-6 text-center text-sm text-muted-foreground">{t("empty")}</p>
+        ) : (
+          disputes.map((dispute) => (
+            <DisputeCard
+              key={dispute.id}
+              dispute={dispute}
+              viewerAddress={address ?? null}
+              isAdmin={isAdmin}
+              totalMembers={memberAddresses.length}
+              onVote={(id, inFavor) => {
+                if (address) void voteOnDispute(id, address, inFavor)
+              }}
+              onResolve={(id, outcome, resolution) => {
+                if (address) void resolveDispute(id, address, outcome, resolution)
+              }}
+            />
+          ))
+        )}
+      </CardContent>
+    </Card>
+  )
+}
diff --git a/frontend/components/disputes/file-dispute-dialog.tsx b/frontend/components/disputes/file-dispute-dialog.tsx
new file mode 100644
index 0000000..7b2225a
--- /dev/null
+++ b/frontend/components/disputes/file-dispute-dialog.tsx
@@ -0,0 +1,212 @@
+"use client"
+
+/**
+ * FileDisputeDialog — member-facing form to raise a dispute (issue #208).
+ * Type select, optional target member, description with live character
+ * counter, and up to three evidence URLs.
+ */
+
+import { useState } from "react"
+import { useTranslations } from "next-intl"
+import { Flag } from "lucide-react"
+import { Button } from "@/components/ui/button"
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle,
+  DialogTrigger,
+} from "@/components/ui/dialog"
+import { Input } from "@/components/ui/input"
+import { Label } from "@/components/ui/label"
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from "@/components/ui/select"
+import { Textarea } from "@/components/ui/textarea"
+import { DISPUTE_DESCRIPTION_MAX_LENGTH, DISPUTE_MAX_EVIDENCE_URLS } from "@/lib/disputes"
+
+const DISPUTE_TYPES = [
+  "missed_deposit",
+  "unfair_penalty",
+  "admin_abuse",
+  "member_misconduct",
+  "other",
+] as const
+
+interface FileDisputeDialogProps {
+  disabled: boolean
+  memberAddresses: string[]
+  submitting: boolean
+  onSubmit: (input: {
+    disputeType: string
+    description: string
+    targetAddress?: string
+    evidenceUrls?: string[]
+  }) => Promise<boolean>
+}
+
+export function FileDisputeDialog({
+  disabled,
+  memberAddresses,
+  submitting,
+  onSubmit,
+}: FileDisputeDialogProps) {
+  const t = useTranslations("group.disputes")
+  const [open, setOpen] = useState(false)
+  const [disputeType, setDisputeType] = useState<string>("")
+  const [targetAddress, setTargetAddress] = useState<string>("none")
+  const [description, setDescription] = useState("")
+  const [evidenceUrls, setEvidenceUrls] = useState<string[]>([""])
+  const [formError, setFormError] = useState<string | null>(null)
+
+  const reset = () => {
+    setDisputeType("")
+    setTargetAddress("none")
+    setDescription("")
+    setEvidenceUrls([""])
+    setFormError(null)
+  }
+
+  const handleSubmit = async () => {
+    if (!disputeType || !description.trim()) return
+    const urls = evidenceUrls.map((u) => u.trim()).filter(Boolean)
+    if (urls.some((u) => !/^https?:\/\//i.test(u))) {
+      setFormError(t("invalidUrl"))
+      return
+    }
+    const ok = await onSubmit({
+      disputeType,
+      description: description.trim(),
+      targetAddress: targetAddress === "none" ? undefined : targetAddress,
+      evidenceUrls: urls.length > 0 ? urls : undefined,
+    })
+    if (ok) {
+      reset()
+      setOpen(false)
+    } else {
+      setFormError(t("submitFailed"))
+    }
+  }
+
+  return (
+    <Dialog
+      open={open}
+      onOpenChange={(next) => {
+        setOpen(next)
+        if (next) reset()
+      }}
+    >
+      <DialogTrigger asChild>
+        <Button size="sm" disabled={disabled}>
+          <Flag className="mr-1.5 h-4 w-4" />
+          {t("fileDispute")}
+        </Button>
+      </DialogTrigger>
+      <DialogContent className="sm:max-w-lg">
+        <DialogHeader>
+          <DialogTitle>{t("fileTitle")}</DialogTitle>
+          <DialogDescription>{t("fileDescription")}</DialogDescription>
+        </DialogHeader>
+
+        <div className="space-y-4">
+          <div className="space-y-2">
+            <Label htmlFor="dispute-type">{t("typeLabel")}</Label>
+            <Select value={disputeType} onValueChange={setDisputeType}>
+              <SelectTrigger id="dispute-type">
+                <SelectValue placeholder={t("typePlaceholder")} />
+              </SelectTrigger>
+              <SelectContent>
+                {DISPUTE_TYPES.map((type) => (
+                  <SelectItem key={type} value={type}>
+                    {t(`types.${type}`)}
+                  </SelectItem>
+                ))}
+              </SelectContent>
+            </Select>
+          </div>
+
+          <div className="space-y-2">
+            <Label htmlFor="dispute-target">{t("targetLabel")}</Label>
+            <Select value={targetAddress} onValueChange={setTargetAddress}>
+              <SelectTrigger id="dispute-target">
+                <SelectValue />
+              </SelectTrigger>
+              <SelectContent>
+                <SelectItem value="none">{t("targetNone")}</SelectItem>
+                {memberAddresses.map((addr) => (
+                  <SelectItem key={addr} value={addr}>
+                    {addr.slice(0, 8)}…{addr.slice(-6)}
+                  </SelectItem>
+                ))}
+              </SelectContent>
+            </Select>
+          </div>
+
+          <div className="space-y-2">
+            <div className="flex items-center justify-between">
+              <Label htmlFor="dispute-description">{t("descriptionLabel")}</Label>
+              <span className="text-xs text-muted-foreground">
+                {description.length}/{DISPUTE_DESCRIPTION_MAX_LENGTH}
+              </span>
+            </div>
+            <Textarea
+              id="dispute-description"
+              value={description}
+              onChange={(e) =>
+                setDescription(e.target.value.slice(0, DISPUTE_DESCRIPTION_MAX_LENGTH))
+              }
+              placeholder={t("descriptionPlaceholder")}
+              rows={4}
+            />
+          </div>
+
+          <div className="space-y-2">
+            <Label>{t("evidenceLabel")}</Label>
+            {evidenceUrls.map((url, i) => (
+              <Input
+                key={i}
+                value={url}
+                onChange={(e) => {
+                  const next = [...evidenceUrls]
+                  next[i] = e.target.value
+                  setEvidenceUrls(next)
+                }}
+                placeholder="https://…"
+              />
+            ))}
+            {evidenceUrls.length < DISPUTE_MAX_EVIDENCE_URLS && (
+              <Button
+                type="button"
+                variant="ghost"
+                size="sm"
+                onClick={() => setEvidenceUrls((prev) => [...prev, ""])}
+              >
+                + {t("addEvidence")}
+              </Button>
+            )}
+          </div>
+
+          {formError && <p className="text-sm text-destructive">{formError}</p>}
+        </div>
+
+        <DialogFooter>
+          <Button variant="outline" onClick={() => setOpen(false)}>
+            {t("cancel")}
+          </Button>
+          <Button
+            onClick={handleSubmit}
+            disabled={!disputeType || !description.trim() || submitting}
+          >
+            {submitting ? t("submitting") : t("submit")}
+          </Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  )
+}
diff --git a/frontend/hooks/useDisputes.ts b/frontend/hooks/useDisputes.ts
new file mode 100644
index 0000000..accdbf8
--- /dev/null
+++ b/frontend/hooks/useDisputes.ts
@@ -0,0 +1,230 @@
+"use client"
+
+/**
+ * useDisputes — pool dispute feed + actions (issue #208)
+ *
+ * Loads disputes for a pool from /api/disputes, keeps them live via a
+ * Supabase Realtime subscription (INSERT/UPDATE on `disputes`), and exposes
+ * file/vote/resolve mutations that optimistically update the local list.
+ */
+
+import { useState, useEffect, useCallback, useRef } from "react"
+import type { RealtimeChannel, RealtimePostgresChangesPayload } from "@supabase/supabase-js"
+import { supabase } from "@/lib/supabase"
+import type { DisputeRecord } from "@/lib/disputes"
+
+const IS_E2E = process.env.NEXT_PUBLIC_E2E === "true"
+
+export interface FileDisputeInput {
+  poolId: string
+  filerAddress: string
+  disputeType: string
+  description: string
+  targetAddress?: string
+  evidenceUrls?: string[]
+}
+
+export interface UseDisputesResult {
+  disputes: DisputeRecord[]
+  loading: boolean
+  error: string | null
+  refresh: () => Promise<void>
+  fileDispute: (input: Omit<FileDisputeInput, "poolId">) => Promise<boolean>
+  voteOnDispute: (disputeId: string, voterAddress: string, inFavor: boolean) => Promise<boolean>
+  resolveDispute: (
+    disputeId: string,
+    adminAddress: string,
+    outcome: "upheld" | "dismissed",
+    resolution: string
+  ) => Promise<boolean>
+}
+
+function sortDisputes(list: DisputeRecord[]): DisputeRecord[] {
+  const statusRank: Record<string, number> = {
+    open: 0,
+    voting: 1,
+    resolved_upheld: 2,
+    resolved_dismissed: 3,
+    expired: 4,
+  }
+  return [...list].sort((a, b) => {
+    const byStatus = (statusRank[a.status] ?? 9) - (statusRank[b.status] ?? 9)
+    if (byStatus !== 0) return byStatus
+    return new Date(b.created_at).getTime() - new Date(a.created_at).getTime()
+  })
+}
+
+export function useDisputes(poolId: string | null): UseDisputesResult {
+  const [disputes, setDisputes] = useState<DisputeRecord[]>([])
+  const [loading, setLoading] = useState(false)
+  const [error, setError] = useState<string | null>(null)
+  const knownIds = useRef<Set<string>>(new Set())
+
+  const refresh = useCallback(async () => {
+    if (!poolId || IS_E2E) return
+    setLoading(true)
+    setError(null)
+    try {
+      const res = await fetch(`/api/disputes?pool_id=${encodeURIComponent(poolId)}`)
+      if (!res.ok) throw new Error(`HTTP ${res.status}`)
+      const data: { disputes: DisputeRecord[] } = await res.json()
+      const list = data.disputes ?? []
+      knownIds.current = new Set(list.map((d) => d.id))
+      setDisputes(sortDisputes(list))
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Failed to load disputes")
+    } finally {
+      setLoading(false)
+    }
+  }, [poolId])
+
+  useEffect(() => {
+    void refresh()
+  }, [refresh])
+
+  // ── Realtime: new or updated disputes replace their local copy ────────────
+
+  useEffect(() => {
+    if (!poolId || IS_E2E || !supabase) return
+
+    const channel: RealtimeChannel = supabase
+      .channel(`disputes:${poolId}`)
+      .on(
+        "postgres_changes",
+        {
+          event: "*",
+          schema: "public",
+          table: "disputes",
+          filter: `pool_id=eq.${poolId}`,
+        },
+        (payload: RealtimePostgresChangesPayload<DisputeRecord>) => {
+          if (payload.eventType === "INSERT") {
+            const row = payload.new as DisputeRecord
+            if (knownIds.current.has(row.id)) return
+            knownIds.current.add(row.id)
+            setDisputes((prev) => sortDisputes([row, ...prev]))
+          } else if (payload.eventType === "UPDATE") {
+            const row = payload.new as DisputeRecord
+            setDisputes((prev) => sortDisputes(prev.map((d) => (d.id === row.id ? row : d))))
+          }
+        }
+      )
+      .subscribe()
+
+    return () => {
+      supabase.removeChannel(channel)
+    }
+  }, [poolId])
+
+  // ── Mutations ──────────────────────────────────────────────────────────────
+
+  const fileDispute = useCallback(
+    async (input: Omit<FileDisputeInput, "poolId">): Promise<boolean> => {
+      if (!poolId || IS_E2E) return false
+      try {
+        const res = await fetch("/api/disputes", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            pool_id: poolId,
+            filer_address: input.filerAddress.toLowerCase(),
+            dispute_type: input.disputeType,
+            description: input.description,
+            ...(input.targetAddress ? { target_address: input.targetAddress } : {}),
+            ...(input.evidenceUrls ? { evidence_urls: input.evidenceUrls } : {}),
+          }),
+        })
+        if (!res.ok) {
+          const body = (await res.json().catch(() => null)) as { error?: string } | null
+          throw new Error(body?.error ?? `Failed to file dispute (HTTP ${res.status})`)
+        }
+        await refresh()
+        return true
+      } catch (err) {
+        setError(err instanceof Error ? err.message : "Failed to file dispute")
+        return false
+      }
+    },
+    [poolId, refresh]
+  )
+
+  const voteOnDispute = useCallback(
+    async (disputeId: string, voterAddress: string, inFavor: boolean): Promise<boolean> => {
+      if (IS_E2E) return false
+      // Optimistic count bump; the realtime UPDATE will reconcile.
+      setDisputes((prev) =>
+        prev.map((d) =>
+          d.id === disputeId
+            ? {
+                ...d,
+                votes_for: d.votes_for + (inFavor ? 1 : 0),
+                votes_against: d.votes_against + (inFavor ? 0 : 1),
+                status: d.status === "open" ? "voting" : d.status,
+              }
+            : d
+        )
+      )
+      try {
+        const res = await fetch(`/api/disputes/${encodeURIComponent(disputeId)}/vote`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            voter_address: voterAddress.toLowerCase(),
+            vote: inFavor,
+          }),
+        })
+        if (!res.ok) {
+          const body = (await res.json().catch(() => null)) as { error?: string } | null
+          throw new Error(body?.error ?? `Vote failed (HTTP ${res.status})`)
+        }
+        const data: { dispute: DisputeRecord } = await res.json()
+        setDisputes((prev) =>
+          sortDisputes(prev.map((d) => (d.id === data.dispute.id ? data.dispute : d)))
+        )
+        return true
+      } catch (err) {
+        setError(err instanceof Error ? err.message : "Vote failed")
+        void refresh() // roll back the optimistic update with server truth
+        return false
+      }
+    },
+    [refresh]
+  )
+
+  const resolveDispute = useCallback(
+    async (
+      disputeId: string,
+      adminAddress: string,
+      outcome: "upheld" | "dismissed",
+      resolution: string
+    ): Promise<boolean> => {
+      if (IS_E2E) return false
+      try {
+        const res = await fetch(`/api/disputes/${encodeURIComponent(disputeId)}/resolve`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            admin_address: adminAddress.toLowerCase(),
+            outcome,
+            resolution,
+          }),
+        })
+        if (!res.ok) {
+          const body = (await res.json().catch(() => null)) as { error?: string } | null
+          throw new Error(body?.error ?? `Resolution failed (HTTP ${res.status})`)
+        }
+        const data: { dispute: DisputeRecord } = await res.json()
+        setDisputes((prev) =>
+          sortDisputes(prev.map((d) => (d.id === data.dispute.id ? data.dispute : d)))
+        )
+        return true
+      } catch (err) {
+        setError(err instanceof Error ? err.message : "Resolution failed")
+        return false
+      }
+    },
+    []
+  )
+
+  return { disputes, loading, error, refresh, fileDispute, voteOnDispute, resolveDispute }
+}
diff --git a/frontend/lib/disputes.test.ts b/frontend/lib/disputes.test.ts
new file mode 100644
index 0000000..dbb8441
--- /dev/null
+++ b/frontend/lib/disputes.test.ts
@@ -0,0 +1,75 @@
+// Unit tests for the dispute resolution helpers (issue #208)
+import { test } from "node:test"
+import assert from "node:assert"
+import {
+  canVoteOnDispute,
+  formatDisputeTimeRemaining,
+  isDisputeExpired,
+  isDisputeType,
+  validateEvidenceUrls,
+  votesNeededToResolve,
+} from "./disputes"
+
+test("votesNeededToResolve - half the pool, rounded up", () => {
+  assert.strictEqual(votesNeededToResolve(5), 3)
+  assert.strictEqual(votesNeededToResolve(4), 2)
+  assert.strictEqual(votesNeededToResolve(1), 1)
+  assert.strictEqual(votesNeededToResolve(0), 0)
+  assert.strictEqual(votesNeededToResolve(NaN), 0)
+})
+
+test("isDisputeType - whitelist", () => {
+  assert.ok(isDisputeType("missed_deposit"))
+  assert.ok(isDisputeType("unfair_penalty"))
+  assert.ok(!isDisputeType("spam"))
+  assert.ok(!isDisputeType(null))
+})
+
+test("formatDisputeTimeRemaining - buckets", () => {
+  const now = new Date("2026-08-24T00:00:00Z").getTime()
+  const plus = (ms: number) => new Date(now + ms).toISOString()
+  assert.strictEqual(formatDisputeTimeRemaining(plus(3 * 86_400_000), now), "3d 00h")
+  assert.strictEqual(formatDisputeTimeRemaining(plus(5 * 3_600_000 + 30 * 60_000), now), "5h 30m")
+  assert.strictEqual(formatDisputeTimeRemaining(plus(60_000 * 7), now), "7m")
+  assert.strictEqual(formatDisputeTimeRemaining(plus(-1), now), "Expired")
+})
+
+test("isDisputeExpired - boundary is inclusive", () => {
+  const now = new Date("2026-08-24T12:00:00Z").getTime()
+  assert.strictEqual(isDisputeExpired(new Date(now).toISOString(), now), true)
+  assert.strictEqual(isDisputeExpired(new Date(now + 1).toISOString(), now), false)
+})
+
+test("validateEvidenceUrls - caps at 3 and rejects non-http schemes", () => {
+  const { valid, invalid } = validateEvidenceUrls([
+    "https://a.example/receipt.png",
+    "javascript:alert(1)",
+    "http://b.example/x",
+    "https://c.example/y",
+    "https://d.example/z",
+  ])
+  // Cap of DISPUTE_MAX_EVIDENCE_URLS applies to the raw list before validation.
+  assert.deepStrictEqual(valid, ["https://a.example/receipt.png", "http://b.example/x"])
+  assert.deepStrictEqual(invalid, ["javascript:alert(1)"])
+})
+
+test("validateEvidenceUrls - ignores junk input", () => {
+  const { valid } = validateEvidenceUrls(["  ", 42, null, "https://ok.example"])
+  assert.deepStrictEqual(valid, ["https://ok.example"])
+})
+
+function dispute(filer = "GAAA", target: string | null = "GBBB") {
+  return { filer_address: filer, target_address: target }
+}
+
+test("canVoteOnDispute - filer and target excluded, others allowed once", () => {
+  assert.strictEqual(canVoteOnDispute("GAAA", dispute(), false), false)
+  assert.strictEqual(canVoteOnDispute("gbbb", dispute(), false), false)
+  assert.strictEqual(canVoteOnDispute("GCCC", dispute(), false), true)
+  assert.strictEqual(canVoteOnDispute("GCCC", dispute(), true), false)
+})
+
+test("canVoteOnDispute - admin-action disputes (null target) allow all but filer", () => {
+  assert.strictEqual(canVoteOnDispute("GCCC", dispute("GAAA", null), false), true)
+  assert.strictEqual(canVoteOnDispute("gaaa", dispute("GAAA", null), false), false)
+})
diff --git a/frontend/lib/disputes.ts b/frontend/lib/disputes.ts
new file mode 100644
index 0000000..09552f6
--- /dev/null
+++ b/frontend/lib/disputes.ts
@@ -0,0 +1,105 @@
+// Pure dispute-resolution domain helpers (issue #207/#208). Framework-free so
+// it runs under the node test runner.
+
+export const DISPUTE_DESCRIPTION_MAX_LENGTH = 2000
+export const DISPUTE_MAX_EVIDENCE_URLS = 3
+/** Disputes auto-expire 72 hours after filing. */
+export const DISPUTE_EXPIRY_HOURS = 72
+
+export type DisputeType =
+  "missed_deposit" | "unfair_penalty" | "admin_abuse" | "member_misconduct" | "other"
+
+export type DisputeStatus = "open" | "voting" | "resolved_upheld" | "resolved_dismissed" | "expired"
+
+export interface EvidenceUrlValidation {
+  valid: string[]
+  invalid: string[]
+}
+
+/** Row shape of the `disputes` table as returned by /api/disputes. */
+export interface DisputeRecord {
+  id: string
+  pool_id: string
+  filer_address: string
+  target_address: string | null
+  dispute_type: string
+  description: string
+  evidence_urls: string[]
+  status: string
+  resolution: string | null
+  votes_for: number
+  votes_against: number
+  resolved_by: string | null
+  resolved_at: string | null
+  created_at: string
+  expires_at: string
+}
+
+export function isDisputeType(value: unknown): value is DisputeType {
+  return (
+    value === "missed_deposit" ||
+    value === "unfair_penalty" ||
+    value === "admin_abuse" ||
+    value === "member_misconduct" ||
+    value === "other"
+  )
+}
+
+/**
+ * Votes required for one side to win: at least half of the pool members.
+ * Mirrors the contract of the vote endpoint — a filer/target cannot vote, but
+ * they still count toward the pool size.
+ */
+export function votesNeededToResolve(totalMembers: number): number {
+  if (!Number.isFinite(totalMembers) || totalMembers <= 0) return 0
+  return Math.ceil(totalMembers / 2)
+}
+
+export function isDisputeExpired(expiresAtIso: string, nowMs: number): boolean {
+  return new Date(expiresAtIso).getTime() <= nowMs
+}
+
+/** Human-readable countdown ("2d 4h", "5h 03m", "<1m"). */
+export function formatDisputeTimeRemaining(expiresAtIso: string, nowMs: number): string {
+  const diff = new Date(expiresAtIso).getTime() - nowMs
+  if (diff <= 0) return "Expired"
+  const minutesTotal = Math.floor(diff / 60_000)
+  if (minutesTotal < 1) return "<1m"
+  const hours = Math.floor(minutesTotal / 60) % 24
+  const days = Math.floor(minutesTotal / 1440)
+  const minutes = minutesTotal % 60
+  if (days > 0) return `${days}d ${hours.toString().padStart(2, "0")}h`
+  if (hours > 0) return `${hours}h ${minutes.toString().padStart(2, "0")}m`
+  return `${minutes}m`
+}
+
+const URL_RE = /^https?:\/\/[^\s]+$/i
+
+/** Split candidate evidence URLs into acceptable and rejected entries. */
+export function validateEvidenceUrls(urls: unknown): EvidenceUrlValidation {
+  const list = Array.isArray(urls) ? urls.filter((u): u is string => typeof u === "string") : []
+  const trimmed = list
+    .map((u) => u.trim())
+    .filter((u) => u.length > 0)
+    .slice(0, DISPUTE_MAX_EVIDENCE_URLS)
+  return {
+    valid: trimmed.filter((u) => URL_RE.test(u)),
+    invalid: trimmed.filter((u) => !URL_RE.test(u)),
+  }
+}
+
+/**
+ * Whether `voter` may cast a vote on the given dispute. Filers and targets are
+ * excluded; everyone else in the pool may vote exactly once.
+ */
+export function canVoteOnDispute(
+  voterAddress: string,
+  dispute: { filer_address: string; target_address: string | null },
+  alreadyVoted: boolean
+): boolean {
+  if (!voterAddress || alreadyVoted) return false
+  if (voterAddress.toLowerCase() === dispute.filer_address.toLowerCase()) return false
+  if (dispute.target_address && voterAddress.toLowerCase() === dispute.target_address.toLowerCase())
+    return false
+  return true
+}
diff --git a/frontend/lib/supabase.ts b/frontend/lib/supabase.ts
index 7fce6ca..d9232e0 100644
--- a/frontend/lib/supabase.ts
+++ b/frontend/lib/supabase.ts
@@ -436,6 +436,79 @@ export type Database = {
         }
         Relationships: []
       }
+      disputes: {
+        Row: {
+          id: string
+          pool_id: string
+          filer_address: string
+          target_address: string | null
+          dispute_type:
+            "missed_deposit" | "unfair_penalty" | "admin_abuse" | "member_misconduct" | "other"
+          description: string
+          evidence_urls: string[]
+          status: "open" | "voting" | "resolved_upheld" | "resolved_dismissed" | "expired"
+          resolution: string | null
+          votes_for: number
+          votes_against: number
+          resolved_by: string | null
+          resolved_at: string | null
+          created_at: string
+          expires_at: string
+        }
+        Insert: {
+          id?: string
+          pool_id: string
+          filer_address: string
+          target_address?: string | null
+          dispute_type:
+            "missed_deposit" | "unfair_penalty" | "admin_abuse" | "member_misconduct" | "other"
+          description: string
+          evidence_urls?: string[]
+          status?: "open" | "voting" | "resolved_upheld" | "resolved_dismissed" | "expired"
+          resolution?: string | null
+          votes_for?: number
+          votes_against?: number
+          resolved_by?: string | null
+          resolved_at?: string | null
+          created_at?: string
+          expires_at: string
+        }
+        Update: {
+          pool_id?: string
+          filer_address?: string
+          target_address?: string | null
+          dispute_type?:
+            "missed_deposit" | "unfair_penalty" | "admin_abuse" | "member_misconduct" | "other"
+          description?: string
+          evidence_urls?: string[]
+          status?: "open" | "voting" | "resolved_upheld" | "resolved_dismissed" | "expired"
+          resolution?: string | null
+          votes_for?: number
+          votes_against?: number
+          resolved_by?: string | null
+          resolved_at?: string | null
+          expires_at?: string
+        }
+        Relationships: []
+      }
+      dispute_votes: {
+        Row: {
+          dispute_id: string
+          voter_address: string
+          vote: boolean
+          created_at: string
+        }
+        Insert: {
+          dispute_id: string
+          voter_address: string
+          vote: boolean
+          created_at?: string
+        }
+        Update: {
+          vote?: boolean
+        }
+        Relationships: []
+      }
       pool_templates: {
         Row: {
           id: string
diff --git a/frontend/messages/en.json b/frontend/messages/en.json
index 6868c28..b95b359 100644
--- a/frontend/messages/en.json
+++ b/frontend/messages/en.json
@@ -936,6 +936,54 @@
       "sectionYieldDashboard": "Yield Dashboard",
       "sectionMembersList": "Members List",
       "loadingLending": "Loading Lending..."
+    },
+    "disputes": {
+      "title": "Disputes",
+      "fileDispute": "File dispute",
+      "empty": "No disputes have been raised in this pool.",
+      "retry": "Retry",
+      "expiresIn": "Voting ends in {time}",
+      "against": "Against",
+      "resolutionNote": "Resolution",
+      "voteCounts": "{for} uphold · {against} dismiss · {needed} needed to decide",
+      "votesCast": "{count} votes cast",
+      "voteUphold": "Uphold",
+      "voteDismiss": "Dismiss",
+      "resolve": "Resolve as admin",
+      "resolveTitle": "Resolve this dispute",
+      "resolveDescription": "As pool admin you can close this dispute with a written resolution. This is logged in the pool activity.",
+      "resolvePlaceholder": "Explain the outcome and reasoning…",
+      "upholdDispute": "Uphold dispute",
+      "dismissDispute": "Dismiss dispute",
+      "invalidUrl": "Evidence links must start with http:// or https://",
+      "submitFailed": "Could not file the dispute. Check that you are a member and don't already have an active dispute.",
+      "cancel": "Cancel",
+      "submit": "File dispute",
+      "submitting": "Filing…",
+      "fileTitle": "File a dispute",
+      "fileDescription": "Raise an issue for the pool members to vote on. Disputes auto-expire 72 hours after filing.",
+      "typeLabel": "Type",
+      "typePlaceholder": "Select a type",
+      "targetLabel": "Against member (optional)",
+      "targetNone": "No specific member / admin action",
+      "descriptionLabel": "What happened?",
+      "descriptionPlaceholder": "Describe what happened, when, and any relevant rounds or transactions…",
+      "evidenceLabel": "Evidence links (optional)",
+      "addEvidence": "Add link",
+      "types": {
+        "missed_deposit": "Missed deposit",
+        "unfair_penalty": "Unfair penalty",
+        "admin_abuse": "Admin action",
+        "member_misconduct": "Member misconduct",
+        "other": "Other"
+      },
+      "status": {
+        "open": "Open",
+        "voting": "Voting",
+        "resolved_upheld": "Upheld",
+        "resolved_dismissed": "Dismissed",
+        "expired": "Expired"
+      }
     }
   },
   "explore": {
diff --git a/frontend/messages/es.json b/frontend/messages/es.json
index 962ea79..6fcbe28 100644
--- a/frontend/messages/es.json
+++ b/frontend/messages/es.json
@@ -944,6 +944,54 @@
       "sectionYieldDashboard": "Panel de Rendimiento",
       "sectionMembersList": "Lista de Miembros",
       "loadingLending": "Cargando Préstamos..."
+    },
+    "disputes": {
+      "title": "Disputas",
+      "fileDispute": "Presentar disputa",
+      "empty": "No se han presentado disputas en este grupo.",
+      "retry": "Reintentar",
+      "expiresIn": "La votación termina en {time}",
+      "against": "Contra",
+      "resolutionNote": "Resolución",
+      "voteCounts": "{for} a favor · {against} en contra · {needed} necesarias para decidir",
+      "votesCast": "{count} votos emitidos",
+      "voteUphold": "A favor",
+      "voteDismiss": "En contra",
+      "resolve": "Resolver como admin",
+      "resolveTitle": "Resolver esta disputa",
+      "resolveDescription": "Como administrador del grupo puedes cerrar esta disputa con una resolución escrita. Esto queda registrado en la actividad del grupo.",
+      "resolvePlaceholder": "Explica el resultado y el motivo…",
+      "upholdDispute": "Aprobar disputa",
+      "dismissDispute": "Rechazar disputa",
+      "invalidUrl": "Los enlaces de evidencia deben empezar por http:// o https://",
+      "submitFailed": "No se pudo presentar la disputa. Verifica que eres miembro y que no tienes otra disputa activa.",
+      "cancel": "Cancelar",
+      "submit": "Presentar disputa",
+      "submitting": "Presentando…",
+      "fileTitle": "Presentar una disputa",
+      "fileDescription": "Plantea un problema para que los miembros voten. Las disputas expiran 72 horas después de presentarse.",
+      "typeLabel": "Tipo",
+      "typePlaceholder": "Selecciona un tipo",
+      "targetLabel": "Contra un miembro (opcional)",
+      "targetNone": "Ningún miembro específico / acción de admin",
+      "descriptionLabel": "¿Qué pasó?",
+      "descriptionPlaceholder": "Describe qué pasó, cuándo, y las rondas o transacciones relevantes…",
+      "evidenceLabel": "Enlaces de evidencia (opcional)",
+      "addEvidence": "Añadir enlace",
+      "types": {
+        "missed_deposit": "Depósito omitido",
+        "unfair_penalty": "Multa injusta",
+        "admin_abuse": "Acción del admin",
+        "member_misconduct": "Mala conducta de un miembro",
+        "other": "Otro"
+      },
+      "status": {
+        "open": "Abierta",
+        "voting": "En votación",
+        "resolved_upheld": "Aprobada",
+        "resolved_dismissed": "Rechazada",
+        "expired": "Expirada"
+      }
     }
   },
   "explore": {
diff --git a/frontend/package.json b/frontend/package.json
index 84b3b8b..99218b9 100644
--- a/frontend/package.json
+++ b/frontend/package.json
@@ -12,7 +12,7 @@
     "format": "prettier --write .",
     "format:check": "prettier --check .",
     "start": "next start",
-    "test:unit": "tsx --test lib/csv-export.test.ts lib/activity-query.test.ts lib/soroban-event-mapping.test.ts lib/analytics.test.ts lib/pool-health.test.ts lib/form-validation.test.ts lib/member-filters.test.ts lib/contract-version.test.ts lib/error-reporting.test.ts lib/pending-transactions.test.ts hooks/use-keyboard-shortcuts.test.ts app/api/admin/audit-log/route.test.ts app/api/admin/actions/route.test.ts app/api/errors/route.test.ts components/error-boundary.test.ts app/api/notifications/route.test.ts app/api/user-profile/route.test.ts app/api/notifications/digest-preferences/route.test.ts app/api/notifications/digest/unsubscribe/route.test.ts app/api/cron/send-digests/route.test.ts app/api/portfolio/summary/route.test.ts app/api/templates/route.test.ts",
+    "test:unit": "tsx --test lib/csv-export.test.ts lib/activity-query.test.ts lib/soroban-event-mapping.test.ts lib/analytics.test.ts lib/pool-health.test.ts lib/form-validation.test.ts lib/member-filters.test.ts lib/contract-version.test.ts lib/error-reporting.test.ts lib/pending-transactions.test.ts lib/disputes.test.ts hooks/use-keyboard-shortcuts.test.ts app/api/admin/audit-log/route.test.ts app/api/admin/actions/route.test.ts app/api/errors/route.test.ts components/error-boundary.test.ts app/api/notifications/route.test.ts app/api/user-profile/route.test.ts app/api/notifications/digest-preferences/route.test.ts app/api/notifications/digest/unsubscribe/route.test.ts app/api/cron/send-digests/route.test.ts app/api/portfolio/summary/route.test.ts app/api/templates/route.test.ts",
     "test:components": "vitest run",
     "test:components:coverage": "vitest run --coverage",
     "test:e2e": "playwright test",
diff --git a/supabase/migrations/20260824010000_dispute_resolution.sql b/supabase/migrations/20260824010000_dispute_resolution.sql
new file mode 100644
index 0000000..bdc5e3d
--- /dev/null
+++ b/supabase/migrations/20260824010000_dispute_resolution.sql
@@ -0,0 +1,81 @@
+-- Migration: Dispute resolution system (issue #208)
+--
+-- Lets pool members file disputes against admin actions or other members,
+-- vote to uphold/dismiss them, and records resolutions. Resolutions are also
+-- mirrored into the pool_activity feed by the API routes.
+
+CREATE TABLE IF NOT EXISTS public.disputes (
+  id             uuid        PRIMARY KEY DEFAULT gen_random_uuid(),
+  pool_id        uuid        NOT NULL REFERENCES public.pools(id) ON DELETE CASCADE,
+  filer_address  text        NOT NULL,
+  target_address text,
+  dispute_type   text        NOT NULL CHECK (dispute_type IN
+                   ('missed_deposit', 'unfair_penalty', 'admin_abuse', 'member_misconduct', 'other')),
+  description    text        NOT NULL,
+  evidence_urls  jsonb       NOT NULL DEFAULT '[]'::jsonb,
+  status         text        NOT NULL DEFAULT 'open' CHECK (status IN
+                   ('open', 'voting', 'resolved_upheld', 'resolved_dismissed', 'expired')),
+  resolution     text,
+  votes_for      integer     NOT NULL DEFAULT 0,
+  votes_against  integer     NOT NULL DEFAULT 0,
+  resolved_by    text,
+  resolved_at    timestamptz,
+  created_at     timestamptz NOT NULL DEFAULT now(),
+  expires_at     timestamptz NOT NULL,
+
+  -- Mirrors DISPUTE_DESCRIPTION_MAX_LENGTH in frontend/lib/disputes.ts
+  CONSTRAINT disputes_description_length CHECK (char_length(description) <= 2000),
+  -- At least one side must be identified; target is null for admin-action disputes.
+  CONSTRAINT disputes_addresses_lowercase
+    CHECK ((filer_address = lower(filer_address))
+      AND (target_address IS NULL OR target_address = lower(target_address))),
+  CONSTRAINT disputes_resolved_fields_pair
+    CHECK (
+      (status IN ('resolved_upheld', 'resolved_dismissed'))
+      = (resolved_by IS NOT NULL AND resolved_at IS NOT NULL)
+    )
+);
+
+-- Indexes for the common queries: per-pool feed and pending-dispute lookups.
+CREATE INDEX IF NOT EXISTS idx_disputes_pool_created
+  ON public.disputes (pool_id, created_at DESC);
+
+CREATE INDEX IF NOT EXISTS idx_disputes_status_expires
+  ON public.disputes (status, expires_at)
+  WHERE status IN ('open', 'voting');
+
+CREATE TABLE IF NOT EXISTS public.dispute_votes (
+  dispute_id    uuid        NOT NULL REFERENCES public.disputes(id) ON DELETE CASCADE,
+  voter_address text        NOT NULL,
+  vote          boolean     NOT NULL,
+  created_at    timestamptz NOT NULL DEFAULT now(),
+
+  PRIMARY KEY (dispute_id, voter_address),
+  CONSTRAINT dispute_votes_voter_lowercase CHECK (voter_address = lower(voter_address))
+);
+
+CREATE INDEX IF NOT EXISTS idx_dispute_votes_voter
+  ON public.dispute_votes (dispute_id, voter_address);
+
+-- ── Row-Level Security ────────────────────────────────────────────────────────
+ALTER TABLE public.disputes ENABLE ROW LEVEL SECURITY;
+ALTER TABLE public.dispute_votes ENABLE ROW LEVEL SECURITY;
+
+-- Public read — dispute outcomes are visible to anyone viewing a pool, same
+-- visibility model as pool_activity / join_requests. Writes go through
+-- /api/disputes* with the service-role key which performs membership checks.
+CREATE POLICY "disputes_select_public"
+  ON public.disputes
+  FOR SELECT
+  USING (true);
+
+CREATE POLICY "dispute_votes_select_public"
+  ON public.dispute_votes
+  FOR SELECT
+  USING (true);
+
+-- No INSERT/UPDATE/DELETE policies = direct anon writes stay denied.
+
+-- ── Realtime publication ──────────────────────────────────────────────────────
+ALTER PUBLICATION supabase_realtime ADD TABLE public.disputes;
+ALTER PUBLICATION supabase_realtime ADD TABLE public.dispute_votes;
diff --git a/vercel.json b/vercel.json
index 2955a1a..cd6f997 100644
--- a/vercel.json
+++ b/vercel.json
@@ -7,6 +7,10 @@
     {
       "path": "/api/cron/deadline-warnings",
       "schedule": "0 * * * *"
+    },
+    {
+      "path": "/api/disputes/expire",
+      "schedule": "0 2 * * *"
     }
   ]
 }