diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index 83ee7e3..9c1ba1c 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -95,6 +95,10 @@ jobs:
         working-directory: smartcontract
         run: cargo build --target wasm32-unknown-unknown --release --manifest-path=contracts/flexible/Cargo.toml
 
+      - name: Build Governance contract
+        working-directory: smartcontract
+        run: cargo build --target wasm32-unknown-unknown --release --manifest-path=contracts/governance/Cargo.toml
+
       - name: Verify WASM artifacts
         working-directory: smartcontract
         run: |
diff --git a/frontend/app/[locale]/dashboard/group/[id]/GroupClient.tsx b/frontend/app/[locale]/dashboard/group/[id]/GroupClient.tsx
index a33912e..5a6d2b4 100644
--- a/frontend/app/[locale]/dashboard/group/[id]/GroupClient.tsx
+++ b/frontend/app/[locale]/dashboard/group/[id]/GroupClient.tsx
@@ -23,6 +23,7 @@ interface Pool {
   contract_address: string
   token_address: string
   pool_members?: { member_address: string }[]
+  governance_contract_id?: string | null
 }
 
 const isPendingAddress = (addr: string) => !addr || addr === "pending_deployment"
@@ -121,6 +122,18 @@ export default function GroupClient({ params }: { params: Promise<{ id: string }
             )}
             <GroupActivity groupId={id} contractAddress={cacheKey} startLedger={0} />
             <PoolChat poolId={id} isMember={isMember} />
+            {pool.governance_contract_id && !isPendingAddress(pool.contract_address) && (
+              <GovernancePanel
+                poolId={pool.id}
+                governanceContractId={pool.governance_contract_id}
+                poolContractAddress={pool.contract_address}
+                poolType={pool.type}
+                isAdmin={
+                  !!address && !!poolAdmin && address.toLowerCase() === poolAdmin.toLowerCase()
+                }
+                isMember={isMember}
+              />
+            )}
           </div>
 
           {/* ── Right column: actions + members ──────────────────────────── */}
diff --git a/frontend/app/api/governance/route.ts b/frontend/app/api/governance/route.ts
new file mode 100644
index 0000000..0a5186b
--- /dev/null
+++ b/frontend/app/api/governance/route.ts
@@ -0,0 +1,117 @@
+/**
+ * /api/governance — Off-chain mirror of DAO governance votes (issue #207).
+ *
+ * Proposals live on-chain; this endpoint only maintains the realtime vote
+ * mirror in `governance_votes` so clients can update counts without
+ * re-querying Soroban RPC.
+ *
+ * GET  /api/governance?pool_id=<id>[&proposal_id=<hex>]
+ *   Returns mirrored votes, newest first.
+ *
+ * POST /api/governance { pool_id, proposal_id, voter_address, vote }
+ *   Upserts the caller's mirrored vote. One row per (proposal_id, voter).
+ */
+
+import { getAdminClient } from "@/lib/supabase-admin"
+import { NextRequest, NextResponse } from "next/server"
+import { readLimiter, writeLimiter } from "@/lib/rate-limit"
+
+const HEX_RE = /^[0-9a-fA-F]{1,128}$/
+
+export async function GET(req: NextRequest) {
+  const limited = readLimiter(req)
+  if (limited) return limited
+
+  const poolId = req.nextUrl.searchParams.get("pool_id")
+  const proposalId = req.nextUrl.searchParams.get("proposal_id")
+
+  if (!poolId) {
+    return NextResponse.json({ error: "pool_id required" }, { status: 400 })
+  }
+
+  try {
+    let query = getAdminClient()
+      .from("governance_votes")
+      .select("proposal_id, voter_address, vote, created_at")
+      .eq("pool_id", poolId)
+
+    if (proposalId) query = query.eq("proposal_id", proposalId.toLowerCase())
+
+    const { data, error } = await query.order("created_at", { ascending: false })
+
+    if (error) throw error
+
+    return NextResponse.json(data ?? [], {
+      headers: { "Cache-Control": "private, no-cache" },
+    })
+  } catch (error) {
+    console.error("Governance votes fetch error:", error)
+    return NextResponse.json(
+      { error: error instanceof Error ? error.message : "Failed to fetch governance votes" },
+      { status: 500 }
+    )
+  }
+}
+
+export async function POST(req: NextRequest) {
+  const limited = writeLimiter(req)
+  if (limited) return limited
+
+  let body: { pool_id?: string; proposal_id?: string; voter_address?: string; vote?: boolean }
+  try {
+    body = await req.json()
+  } catch {
+    return NextResponse.json({ error: "Invalid JSON" }, { status: 400 })
+  }
+
+  const { pool_id, proposal_id, voter_address, vote } = body
+  const voter = voter_address?.toLowerCase()
+
+  if (!pool_id || !proposal_id || !voter || typeof vote !== "boolean") {
+    return NextResponse.json(
+      { error: "pool_id, proposal_id, voter_address and vote are required" },
+      { status: 400 }
+    )
+  }
+  if (!HEX_RE.test(proposal_id)) {
+    return NextResponse.json({ error: "proposal_id must be a hex string" }, { status: 400 })
+  }
+
+  // Only actual members of the pool may contribute to the mirror.
+  const { data: member } = await getAdminClient()
+    .from("pool_members")
+    .select("id")
+    .eq("pool_id", pool_id)
+    .eq("member_address", voter)
+    .maybeSingle()
+
+  if (!member) {
+    return NextResponse.json({ error: "Not a member of this pool" }, { status: 403 })
+  }
+
+  try {
+    const { data, error } = await getAdminClient()
+      .from("governance_votes")
+      .upsert(
+        {
+          pool_id,
+          proposal_id: proposal_id.toLowerCase(),
+          voter_address: voter,
+          vote,
+        },
+        { onConflict: "proposal_id,voter_address" }
+      )
+      .select("proposal_id, voter_address, vote, created_at")
+      .single()
+
+    if (error) throw error
+
+    return NextResponse.json(data, { status: 201 })
+  } catch (error) {
+    console.error("Governance vote mirror error:", error)
+    return NextResponse.json(
+      { error: error instanceof Error ? error.message : "Failed to record governance vote" },
+      { status: 500 }
+    )
+  }
+}
diff --git a/frontend/components/governance/create-proposal-dialog.tsx b/frontend/components/governance/create-proposal-dialog.tsx
new file mode 100644
index 0000000..237bf43
--- /dev/null
+++ b/frontend/components/governance/create-proposal-dialog.tsx
@@ -0,0 +1,204 @@
+"use client"
+
+import { useMemo, useState } from "react"
+import { useTranslations } from "next-intl"
+import { Loader2 } from "lucide-react"
+import { Button } from "@/components/ui/button"
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle,
+} from "@/components/ui/dialog"
+import { Input } from "@/components/ui/input"
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from "@/components/ui/select"
+import { Textarea } from "@/components/ui/textarea"
+import { Label } from "@/components/ui/label"
+import {
+  GOVERNANCE_DESCRIPTION_MAX,
+  PROPOSAL_TYPES,
+  encodeParamHex,
+  type GovernanceProposalType,
+} from "@/lib/governance"
+
+interface CreateProposalDialogProps {
+  open: boolean
+  onOpenChange: (open: boolean) => void
+  poolType: string
+  onSubmit: (
+    proposalType: GovernanceProposalType,
+    description: string,
+    paramsHex: Record<string, string>
+  ) => Promise<boolean>
+}
+
+const APPLICABLE_POOL_TYPES: Record<string, string[]> = {
+  ChangeDepositAmount: ["flexible", "rotational"],
+  ExtendDeadline: ["rotational", "target"],
+  AddPenalty: ["flexible", "rotational", "target"],
+  RemovePenalty: ["flexible", "rotational", "target"],
+  ChangeQuorum: ["flexible", "rotational", "target"],
+}
+
+export function CreateProposalDialog({
+  open,
+  onOpenChange,
+  poolType,
+  onSubmit,
+}: CreateProposalDialogProps) {
+  const t = useTranslations("governance")
+
+  const availableTypes = useMemo(
+    () => PROPOSAL_TYPES.filter((p) => APPLICABLE_POOL_TYPES[p.value]?.includes(poolType)),
+    [poolType]
+  )
+
+  const [proposalType, setProposalType] = useState<GovernanceProposalType | "">("")
+  const [description, setDescription] = useState("")
+  const [paramValue, setParamValue] = useState("")
+  const [submitting, setSubmitting] = useState(false)
+  const [error, setError] = useState<string | null>(null)
+
+  const selectedMeta = availableTypes.find((p) => p.value === proposalType) ?? null
+  const needsParam = !!selectedMeta?.paramKey
+
+  const reset = () => {
+    setProposalType("")
+    setDescription("")
+    setParamValue("")
+    setSubmitting(false)
+    setError(null)
+  }
+
+  const handleClose = (next: boolean) => {
+    if (!next) reset()
+    onOpenChange(next)
+  }
+
+  const handleSubmit = async () => {
+    if (!proposalType || description.trim().length === 0 || (needsParam && !paramValue)) {
+      setError(t("fillRequired"))
+      return
+    }
+    setSubmitting(true)
+    setError(null)
+    try {
+      let params: Record<string, string> = {}
+      if (needsParam) {
+        params = {
+          [selectedMeta!.paramKey]: encodeParamHex(Number(paramValue.replace(/,/g, ""))),
+        }
+      }
+      const ok = await onSubmit(proposalType, description.trim(), params)
+      if (!ok) {
+        setError(t("toastError"))
+        setSubmitting(false)
+        return
+      }
+      reset()
+      onOpenChange(false)
+    } catch {
+      setError(t("toastError"))
+      setSubmitting(false)
+    }
+  }
+
+  return (
+    <Dialog open={open} onOpenChange={handleClose}>
+      <DialogContent className="sm:max-w-md">
+        <DialogHeader>
+          <DialogTitle>{t("createProposal")}</DialogTitle>
+          <DialogDescription>{t("subtitle")}</DialogDescription>
+        </DialogHeader>
+
+        <div className="space-y-4 py-2">
+          <div className="space-y-2">
+            <Label htmlFor="proposal-type">{t("typeLabel")}</Label>
+            <Select
+              value={proposalType}
+              onValueChange={(v) => {
+                setProposalType(v as GovernanceProposalType)
+                setParamValue("")
+              }}
+            >
+              <SelectTrigger id="proposal-type" className="w-full">
+                <SelectValue placeholder={t("typeLabel")} />
+              </SelectTrigger>
+              <SelectContent>
+                {availableTypes.map((p) => (
+                  <SelectItem key={p.value} value={p.value}>
+                    {t(`types.${p.value}`)}
+                  </SelectItem>
+                ))}
+              </SelectContent>
+            </Select>
+          </div>
+
+          {needsParam && (
+            <div className="space-y-2">
+              <Label htmlFor="proposal-param">{selectedMeta!.paramLabel}</Label>
+              <Input
+                id="proposal-param"
+                type="number"
+                min="0"
+                value={paramValue}
+                onChange={(e) => setParamValue(e.target.value)}
+                placeholder="0"
+              />
+            </div>
+          )}
+
+          <div className="space-y-2">
+            <div className="flex items-center justify-between">
+              <Label htmlFor="proposal-description">{t("descriptionLabel")}</Label>
+              <span
+                className={`text-xs ${
+                  description.length > GOVERNANCE_DESCRIPTION_MAX
+                    ? "text-destructive"
+                    : "text-muted-foreground"
+                }`}
+              >
+                {t("charCount", { count: description.length, max: GOVERNANCE_DESCRIPTION_MAX })}
+              </span>
+            </div>
+            <Textarea
+              id="proposal-description"
+              value={description}
+              onChange={(e) => setDescription(e.target.value.slice(0, GOVERNANCE_DESCRIPTION_MAX))}
+              placeholder={t("descriptionPlaceholder")}
+              rows={4}
+            />
+          </div>
+
+          {error && <p className="text-sm text-destructive">{error}</p>}
+        </div>
+
+        <DialogFooter className="gap-2 sm:gap-0">
+          <Button variant="outline" onClick={() => handleClose(false)} disabled={submitting}>
+            {t("cancel")}
+          </Button>
+          <Button
+            onClick={handleSubmit}
+            disabled={
+              submitting ||
+              !proposalType ||
+              description.trim().length === 0 ||
+              (needsParam && !paramValue)
+            }
+          >
+            {submitting && <Loader2 className="mr-1 h-4 w-4 animate-spin" />}
+            {submitting ? t("submitting") : t("submit")}
+          </Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  )
+}
diff --git a/frontend/components/governance/governance-panel.tsx b/frontend/components/governance/governance-panel.tsx
new file mode 100644
index 0000000..1bb1f35
--- /dev/null
+++ b/frontend/components/governance/governance-panel.tsx
@@ -0,0 +1,151 @@
+"use client"
+
+import { useCallback, useEffect, useState } from "react"
+import { useTranslations } from "next-intl"
+import { Landmark, Plus } from "lucide-react"
+import { Button } from "@/components/ui/button"
+import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card"
+import { Skeleton } from "@/components/ui/skeleton"
+import { toastManager } from "@/lib/toast"
+import { useGovernance } from "@/hooks/useGovernance"
+import { CreateProposalDialog } from "./create-proposal-dialog"
+import { ProposalList } from "./proposal-list"
+import type { GovernanceProposalType } from "@/lib/governance"
+
+interface GovernancePanelProps {
+  poolId: string
+  governanceContractId: string
+  poolContractAddress: string
+  poolType: string
+  isAdmin: boolean
+  isMember: boolean
+}
+
+function useNowSeconds() {
+  const [nowSecs, setNowSecs] = useState(() => Math.floor(Date.now() / 1000))
+  useEffect(() => {
+    const timer = setInterval(() => setNowSecs(Math.floor(Date.now() / 1000)), 30_000)
+    return () => clearInterval(timer)
+  }, [])
+  return nowSecs
+}
+
+export function GovernancePanel({
+  poolId,
+  governanceContractId,
+  poolContractAddress,
+  poolType,
+  isAdmin,
+  isMember,
+}: GovernancePanelProps) {
+  const t = useTranslations("governance")
+  const nowSecs = useNowSeconds()
+  const [dialogOpen, setDialogOpen] = useState(false)
+  const [votingId, setVotingId] = useState<string | null>(null)
+  const [executingId, setExecutingId] = useState<string | null>(null)
+
+  const {
+    proposals,
+    quorum,
+    totalMembers,
+    votesNeeded,
+    loading,
+    address,
+    createProposal,
+    vote,
+    executeProposal,
+  } = useGovernance(poolId, governanceContractId, poolContractAddress)
+
+  const handleVote = useCallback(
+    async (proposalId: string, inFavor: boolean) => {
+      setVotingId(proposalId)
+      try {
+        const ok = await vote(proposalId, inFavor)
+        if (ok) {
+          toastManager.success(t("toastVoteRecorded"))
+        } else {
+          toastManager.error(t("toastError"))
+        }
+      } finally {
+        setVotingId(null)
+      }
+    },
+    [vote, t]
+  )
+
+  const handleExecute = useCallback(
+    async (proposalId: string) => {
+      setExecutingId(proposalId)
+      try {
+        const ok = await executeProposal(proposalId)
+        if (ok) {
+          toastManager.success(t("toastExecuted"))
+        } else {
+          toastManager.error(t("toastError"))
+        }
+      } finally {
+        setExecutingId(null)
+      }
+    },
+    [executeProposal, t]
+  )
+
+  const handleSubmitProposal = useCallback(
+    async (
+      proposalType: GovernanceProposalType,
+      description: string,
+      paramsHex: Record<string, string>
+    ) => createProposal(proposalType, description, paramsHex),
+    [createProposal]
+  )
+
+  return (
+    <Card>
+      <CardHeader className="flex flex-row items-center justify-between space-y-0">
+        <div>
+          <CardTitle className="flex items-center gap-2 text-lg">
+            <Landmark className="h-5 w-5" />
+            {t("title")}
+          </CardTitle>
+          <p className="mt-1 text-xs text-muted-foreground">
+            {t("quorumInfo", { needed: votesNeeded, total: totalMembers || "–", quorum })}
+          </p>
+        </div>
+        {isMember && (
+          <Button size="sm" onClick={() => setDialogOpen(true)}>
+            <Plus className="mr-1 h-4 w-4" />
+            {t("createProposal")}
+          </Button>
+        )}
+      </CardHeader>
+      <CardContent>
+        {loading && proposals.length === 0 ? (
+          <div className="space-y-3">
+            <Skeleton className="h-32 w-full" />
+            <Skeleton className="h-32 w-full" />
+          </div>
+        ) : (
+          <ProposalList
+            proposals={proposals}
+            votesNeeded={votesNeeded}
+            nowSecs={nowSecs}
+            currentAddress={address}
+            isAdmin={isAdmin}
+            isMember={isMember}
+            votingId={votingId}
+            executingId={executingId}
+            onVote={handleVote}
+            onExecute={handleExecute}
+          />
+        )}
+      </CardContent>
+
+      <CreateProposalDialog
+        open={dialogOpen}
+        onOpenChange={setDialogOpen}
+        poolType={poolType}
+        onSubmit={handleSubmitProposal}
+      />
+    </Card>
+  )
+}
diff --git a/frontend/components/governance/proposal-list.tsx b/frontend/components/governance/proposal-list.tsx
new file mode 100644
index 0000000..6b9f21c
--- /dev/null
+++ b/frontend/components/governance/proposal-list.tsx
@@ -0,0 +1,109 @@
+"use client"
+
+import { useState } from "react"
+import { useTranslations } from "next-intl"
+import { ChevronDown, FileText } from "lucide-react"
+import { Badge } from "@/components/ui/badge"
+import { Button } from "@/components/ui/button"
+import { Collapsible, CollapsibleContent, CollapsibleTrigger } from "@/components/ui/collapsible"
+import type { GovernanceProposal, GovernanceProposalStatus } from "@/lib/governance"
+import { VoteCard } from "./vote-card"
+
+const STATUS_BADGE: Record<GovernanceProposalStatus, string> = {
+  Active: "bg-blue-500/15 text-blue-600 dark:text-blue-400 border-blue-500/30",
+  Passed: "bg-green-500/15 text-green-600 dark:text-green-400 border-green-500/30",
+  Executed: "bg-gray-500/15 text-gray-600 dark:text-gray-400 border-gray-500/30",
+  Expired: "bg-orange-500/15 text-orange-600 dark:text-orange-400 border-orange-500/30",
+  Rejected: "bg-red-500/15 text-red-600 dark:text-red-400 border-red-500/30",
+}
+
+interface ProposalListProps {
+  proposals: GovernanceProposal[]
+  votesNeeded: number
+  nowSecs: number
+  currentAddress?: string | null
+  isAdmin: boolean
+  isMember: boolean
+  votingId: string | null
+  executingId: string | null
+  onVote: (proposalId: string, inFavor: boolean) => void
+  onExecute: (proposalId: string) => void
+}
+
+export function ProposalList({
+  proposals,
+  votesNeeded,
+  nowSecs,
+  currentAddress,
+  isAdmin,
+  isMember,
+  votingId,
+  executingId,
+  onVote,
+  onExecute,
+}: ProposalListProps) {
+  const t = useTranslations("governance")
+  const [showRecent, setShowRecent] = useState(false)
+
+  const openProposals = proposals.filter((p) => p.status === "Active" || p.status === "Passed")
+  const recentProposals = proposals.filter((p) => !openProposals.includes(p))
+
+  if (proposals.length === 0) {
+    return (
+      <div className="flex flex-col items-center gap-1 rounded-lg border border-dashed p-6 text-center">
+        <FileText className="h-8 w-8 text-muted-foreground" />
+        <p className="text-sm font-medium">{t("emptyState")}</p>
+        <p className="text-xs text-muted-foreground">{t("emptyHint")}</p>
+      </div>
+    )
+  }
+
+  return (
+    <div className="space-y-4">
+      {openProposals.map((proposal) => (
+        <VoteCard
+          key={proposal.id}
+          proposal={proposal}
+          votesNeeded={votesNeeded}
+          nowSecs={nowSecs}
+          currentAddress={currentAddress}
+          isAdmin={isAdmin}
+          isMember={isMember}
+          votingId={votingId}
+          executingId={executingId}
+          onVote={onVote}
+          onExecute={onExecute}
+        />
+      ))}
+
+      {recentProposals.length > 0 && (
+        <Collapsible open={showRecent} onOpenChange={setShowRecent}>
+          <CollapsibleTrigger asChild>
+            <Button variant="ghost" size="sm" className="w-full">
+              <ChevronDown
+                className={`mr-1 h-4 w-4 transition-transform ${showRecent ? "rotate-180" : ""}`}
+              />
+              {showRecent ? t("hideRecent") : `${t("recentTitle")} (${recentProposals.length})`}
+            </Button>
+          </CollapsibleTrigger>
+          <CollapsibleContent className="space-y-2 pt-2">
+            {recentProposals.map((proposal) => (
+              <div
+                key={proposal.id}
+                className="flex items-start gap-2 rounded-md border p-3 text-sm"
+              >
+                <Badge variant="outline" className={`shrink-0 ${STATUS_BADGE[proposal.status]}`}>
+                  {t(`statuses.${proposal.status}`)}
+                </Badge>
+                <span className="line-clamp-2 flex-1">{proposal.description}</span>
+                <span className="shrink-0 text-xs text-muted-foreground">
+                  {proposal.votesFor.length}/{proposal.votesAgainst.length}
+                </span>
+              </div>
+            ))}
+          </CollapsibleContent>
+        </Collapsible>
+      )}
+    </div>
+  )
+}
diff --git a/frontend/components/governance/vote-card.tsx b/frontend/components/governance/vote-card.tsx
new file mode 100644
index 0000000..879b0c9
--- /dev/null
+++ b/frontend/components/governance/vote-card.tsx
@@ -0,0 +1,160 @@
+"use client"
+
+import { useTranslations } from "next-intl"
+import { CheckCircle2, ThumbsDown, ThumbsUp, XCircle } from "lucide-react"
+import { Badge } from "@/components/ui/badge"
+import { Button } from "@/components/ui/button"
+import { Card, CardContent, CardHeader } from "@/components/ui/card"
+import { Progress } from "@/components/ui/progress"
+import { cn } from "@/lib/utils"
+import {
+  formatTimeRemaining,
+  type GovernanceProposal,
+  type GovernanceProposalStatus,
+} from "@/lib/governance"
+import { PROPOSAL_TYPES } from "@/lib/governance"
+
+const STATUS_BADGE: Record<GovernanceProposalStatus, string> = {
+  Active: "bg-blue-500/15 text-blue-600 dark:text-blue-400 border-blue-500/30",
+  Passed: "bg-green-500/15 text-green-600 dark:text-green-400 border-green-500/30",
+  Executed: "bg-gray-500/15 text-gray-600 dark:text-gray-400 border-gray-500/30",
+  Expired: "bg-orange-500/15 text-orange-600 dark:text-orange-400 border-orange-500/30",
+  Rejected: "bg-red-500/15 text-red-600 dark:text-red-400 border-red-500/30",
+}
+
+export function proposalTypeLabel(type: string): string {
+  return PROPOSAL_TYPES.find((t) => t.value === type)?.label ?? type
+}
+
+function shortenAddress(addr: string): string {
+  return addr.length > 12 ? `${addr.slice(0, 6)}…${addr.slice(-4)}` : addr
+}
+
+interface VoteCardProps {
+  proposal: GovernanceProposal
+  votesNeeded: number
+  nowSecs: number
+  currentAddress?: string | null
+  isAdmin: boolean
+  isMember: boolean
+  votingId: string | null
+  executingId: string | null
+  onVote: (proposalId: string, inFavor: boolean) => void
+  onExecute: (proposalId: string) => void
+}
+
+export function VoteCard({
+  proposal,
+  votesNeeded,
+  nowSecs,
+  currentAddress,
+  isAdmin,
+  isMember,
+  votingId,
+  executingId,
+  onVote,
+  onExecute,
+}: VoteCardProps) {
+  const t = useTranslations("governance")
+
+  const forCount = proposal.votesFor.length
+  const againstCount = proposal.votesAgainst.length
+  const progressTarget = Math.max(votesNeeded, 1)
+  const isProposer =
+    !!currentAddress && proposal.proposer.toLowerCase() === currentAddress.toLowerCase()
+  const alreadyVoted =
+    !!currentAddress &&
+    (proposal.votesFor.some((v) => v.toLowerCase() === currentAddress.toLowerCase()) ||
+      proposal.votesAgainst.some((v) => v.toLowerCase() === currentAddress.toLowerCase()))
+  const open = proposal.status === "Active" || proposal.status === "Passed"
+  const canVote = open && isMember && !isProposer && !alreadyVoted && votingId !== proposal.id
+
+  return (
+    <Card>
+      <CardHeader className="pb-2">
+        <div className="flex flex-wrap items-center gap-2">
+          <Badge variant="outline">{t(`types.${proposal.proposalType}`)}</Badge>
+          <Badge variant="outline" className={STATUS_BADGE[proposal.status]}>
+            {t(`statuses.${proposal.status}`)}
+          </Badge>
+          <span className="ml-auto text-xs text-muted-foreground">
+            {open ? t("timeLeft", { time: formatTimeRemaining(proposal.expiresAt, nowSecs) }) : ""}
+          </span>
+        </div>
+      </CardHeader>
+      <CardContent className="space-y-4">
+        <p className="text-sm whitespace-pre-wrap">{proposal.description}</p>
+        <p className="text-xs text-muted-foreground">
+          by <span className="font-mono">{shortenAddress(proposal.proposer)}</span>
+          {isProposer ? " (you)" : ""}
+        </p>
+
+        <div className="space-y-1.5">
+          <div className="flex items-center justify-between text-sm">
+            <span className="flex items-center gap-1 text-green-600 dark:text-green-400">
+              <ThumbsUp className="h-3.5 w-3.5" /> {forCount}
+            </span>
+            <span className="text-xs text-muted-foreground">
+              {votesNeeded} needed · {againstCount} against
+            </span>
+          </div>
+          <Progress value={Math.min((forCount / progressTarget) * 100, 100)} />
+        </div>
+
+        {open && (
+          <div className="flex flex-wrap items-center gap-2">
+            <Button
+              size="sm"
+              variant="outline"
+              disabled={!canVote || votingId !== null}
+              onClick={() => onVote(proposal.id, true)}
+              className="flex-1 min-w-28 touch-manipulation"
+            >
+              <ThumbsUp className="mr-1 h-4 w-4" />
+              {votingId === proposal.id ? t("voting") : t("voteFor")}
+            </Button>
+            <Button
+              size="sm"
+              variant="outline"
+              disabled={!canVote || votingId !== null}
+              onClick={() => onVote(proposal.id, false)}
+              className="flex-1 min-w-28 touch-manipulation"
+            >
+              <ThumbsDown className="mr-1 h-4 w-4" />
+              {t("voteAgainst")}
+            </Button>
+            {isAdmin && (
+              <Button
+                size="sm"
+                disabled={
+                  proposal.status !== "Passed" ||
+                  nowSecs >= proposal.expiresAt ||
+                  executingId !== null
+                }
+                onClick={() => onExecute(proposal.id)}
+                className={cn("min-w-28", proposal.status === "Passed" && "border-green-500/40")}
+                variant="default"
+              >
+                <CheckCircle2 className="mr-1 h-4 w-4" />
+                {executingId === proposal.id ? t("executing") : t("execute")}
+              </Button>
+            )}
+          </div>
+        )}
+
+        {!open && (
+          <p className="flex items-center gap-1 text-xs text-muted-foreground">
+            <XCircle className="h-3.5 w-3.5" /> {t("closed")}
+          </p>
+        )}
+
+        {open && !alreadyVoted && isProposer && (
+          <p className="text-xs text-muted-foreground">{t("ownProposal")}</p>
+        )}
+        {open && alreadyVoted && (
+          <p className="text-xs text-muted-foreground">{t("alreadyVoted")}</p>
+        )}
+      </CardContent>
+    </Card>
+  )
+}
diff --git a/frontend/hooks/useGovernance.ts b/frontend/hooks/useGovernance.ts
new file mode 100644
index 0000000..11a40fb
--- /dev/null
+++ b/frontend/hooks/useGovernance.ts
@@ -0,0 +1,178 @@
+"use client"
+
+import { useCallback, useEffect, useRef, useState } from "react"
+import { supabase } from "@/lib/supabase"
+import { useStellar } from "@/components/web3-provider"
+import {
+  fetchActiveProposals,
+  fetchGovernanceQuorum,
+  fetchPoolMembers,
+  fetchRecentProposals,
+  useCreateProposal as useChainCreateProposal,
+  useExecuteProposal as useChainExecuteProposal,
+  useGovernanceVote as useChainVote,
+  type GovernanceProposal,
+} from "@/hooks/useJointSaveContracts"
+import { mergeProposals, votesNeededForQuorum } from "@/lib/governance"
+
+const IS_E2E = process.env.NEXT_PUBLIC_E2E === "true"
+
+interface GovernanceVoteRow {
+  proposal_id: string
+  voter_address: string
+  vote: boolean
+}
+
+/**
+ * Loads on-chain proposals for a pool's governance contract and keeps the UI
+ * fresh: Soroban RPC provides the source of truth while a Supabase Realtime
+ * subscription on the `governance_votes` mirror triggers refetches so vote
+ * counts update without a page refresh.
+ */
+export function useGovernance(
+  poolId: string | null,
+  govContractId: string | null,
+  poolContractId: string | null
+) {
+  const { address } = useStellar()
+  const [proposals, setProposals] = useState<GovernanceProposal[]>([])
+  const [quorum, setQuorum] = useState<number>(51)
+  const [totalMembers, setTotalMembers] = useState<number>(0)
+  const [loading, setLoading] = useState(false)
+  const refreshTimer = useRef<ReturnType<typeof setTimeout> | null>(null)
+
+  const chainCreateProposal = useChainCreateProposal(govContractId ?? "")
+  const chainVote = useChainVote(govContractId ?? "")
+  const chainExecuteProposal = useChainExecuteProposal(govContractId ?? "")
+
+  const refresh = useCallback(async () => {
+    if (!govContractId || IS_E2E) {
+      setProposals([])
+      return
+    }
+    setLoading(true)
+    try {
+      const [active, recent, quorumVal] = await Promise.all([
+        poolContractId
+          ? fetchActiveProposals(govContractId, poolContractId)
+          : Promise.resolve([] as GovernanceProposal[]),
+        fetchRecentProposals(govContractId),
+        fetchGovernanceQuorum(govContractId),
+      ])
+      setProposals(mergeProposals(active, recent))
+      if (quorumVal !== null) setQuorum(quorumVal)
+      if (poolContractId) {
+        const members = await fetchPoolMembers(poolContractId)
+        setTotalMembers(members.length)
+      }
+    } catch {
+      setProposals([])
+    } finally {
+      setLoading(false)
+    }
+  }, [govContractId, poolContractId])
+
+  useEffect(() => {
+    refresh()
+  }, [refresh])
+
+  useEffect(() => {
+    if (!poolId || IS_E2E || !supabase) return
+
+    const scheduleRefresh = () => {
+      if (refreshTimer.current) clearTimeout(refreshTimer.current)
+      refreshTimer.current = setTimeout(() => {
+        refresh()
+      }, 1500)
+    }
+
+    const channel = supabase
+      .channel(`governance_votes:${poolId}`)
+      .on(
+        "postgres_changes",
+        {
+          event: "*",
+          schema: "public",
+          table: "governance_votes",
+          filter: `pool_id=eq.${poolId}`,
+        },
+        scheduleRefresh
+      )
+      .subscribe()
+
+    return () => {
+      if (refreshTimer.current) clearTimeout(refreshTimer.current)
+      supabase.removeChannel(channel)
+    }
+  }, [poolId, refresh])
+
+  /** Mirror an on-chain vote into Supabase for realtime fan-out. Best-effort. */
+  const mirrorVote = useCallback(
+    async (proposalIdHex: string, inFavor: boolean) => {
+      if (!poolId || !address || IS_E2E || !supabase) return
+      try {
+        await window.fetch("/api/governance", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            pool_id: poolId,
+            proposal_id: proposalIdHex,
+            voter_address: address.toLowerCase(),
+            vote: inFavor,
+          }),
+        })
+      } catch {}
+    },
+    [poolId, address]
+  )
+
+  const createProposal = useCallback(
+    async (
+      proposalType: string,
+      description: string,
+      paramsHex: Record<string, string>
+    ): Promise<boolean> => {
+      const hash = await chainCreateProposal.createProposal(proposalType, description, paramsHex)
+      if (!hash) return false
+      await refresh()
+      return true
+    },
+    [chainCreateProposal, refresh]
+  )
+
+  const vote = useCallback(
+    async (proposalIdHex: string, inFavor: boolean): Promise<boolean> => {
+      const hash = await chainVote.vote(proposalIdHex, inFavor)
+      if (!hash) return false
+      await mirrorVote(proposalIdHex, inFavor)
+      await refresh()
+      return true
+    },
+    [chainVote, mirrorVote, refresh]
+  )
+
+  const executeProposal = useCallback(
+    async (proposalIdHex: string): Promise<boolean> => {
+      const hash = await chainExecuteProposal.executeProposal(proposalIdHex)
+      if (!hash) return false
+      await refresh()
+      return true
+    },
+    [chainExecuteProposal, refresh]
+  )
+
+  return {
+    proposals,
+    quorum,
+    totalMembers,
+    votesNeeded: votesNeededForQuorum(quorum, totalMembers),
+    loading,
+    address,
+    refresh,
+    createProposal,
+    vote,
+    executeProposal,
+  }
+}
+
+export type { GovernanceVoteRow }
diff --git a/frontend/hooks/useJointSaveContracts.ts b/frontend/hooks/useJointSaveContracts.ts
index f26b67c..9e28509 100644
--- a/frontend/hooks/useJointSaveContracts.ts
+++ b/frontend/hooks/useJointSaveContracts.ts
@@ -1742,3 +1742,219 @@ export function useBumpPoolState(contractId: string) {
 
   return { bumpPoolState, isLoading }
 }
+
+// ── DAO governance (issue #207) ───────────────────────────────────────────────
+
+export type GovernanceProposalStatus = "Active" | "Passed" | "Executed" | "Expired" | "Rejected"
+
+export type GovernanceProposalType =
+  | "ChangeDepositAmount"
+  | "ExtendDeadline"
+  | "AddPenalty"
+  | "RemovePenalty"
+  | "ChangeQuorum"
+  | "Custom"
+
+export interface GovernanceProposal {
+  id: string
+  proposer: string
+  proposalType: GovernanceProposalType
+  description: string
+  votesFor: string[]
+  votesAgainst: string[]
+  status: GovernanceProposalStatus
+  createdAt: number
+  expiresAt: number
+}
+
+const PROPOSAL_STATUSES = new Set(["Active", "Passed", "Executed", "Expired", "Rejected"])
+
+/** Build the scvBytes value for a BytesN<32> proposal id from hex. */
+export function proposalIdVal(idHex: string): xdr.ScVal {
+  const clean = idHex.replace(/^0x/, "").toLowerCase()
+  if (!/^[0-9a-f]{64}$/.test(clean)) throw new Error("invalid proposal id")
+  return nativeToScVal(Buffer.from(clean, "hex"), { type: "bytes" })
+}
+
+function scMapEntry(key: string, val: xdr.ScVal): xdr.ScMapEntry {
+  return new xdr.ScMapEntry({
+    key: nativeToScVal(key, { type: "string" }),
+    val,
+  })
+}
+
+/**
+ * Serialize client-side parameters into the contract's Map<String, Bytes>
+ * shape. Values are i128 big-endian, matching lib/governance.encodeParamHex.
+ */
+export function governanceParamsVal(params: Record<string, string>): xdr.ScVal {
+  return nativeToScVal(
+    Object.entries(params).map(([key, hex]) =>
+      scMapEntry(key, nativeToScVal(Buffer.from(hex, "hex"), { type: "bytes" }))
+    )
+  )
+}
+
+function parseProposal(val: xdr.ScVal): GovernanceProposal | null {
+  try {
+    if (val.switch().name !== "scvMap") return null
+    const field = (name: string) => structField(val, name)
+
+    const idSc = field("id")
+    const idBuf = idSc && idSc.switch().name === "scvBytes" ? (idSc.bytes() as Buffer) : null
+    if (!idBuf || idBuf.length !== 32) return null
+
+    const statusRaw = scValToText(field("status") ?? xdr.ScVal.scvVoid())
+    const typeRaw = scValToText(field("proposal_type") ?? xdr.ScVal.scvVoid())
+
+    return {
+      id: idBuf.toString("hex"),
+      proposer: scValToString(field("proposer") ?? xdr.ScVal.scvVoid()),
+      proposalType: (typeRaw || "Custom") as GovernanceProposalType,
+      description:
+        field("description")?.switch().name === "scvString"
+          ? field("description")!.str().toString()
+          : "",
+      votesFor: field("votes_for")?.vec()?.map(scValToString) ?? [],
+      votesAgainst: field("votes_against")?.vec()?.map(scValToString) ?? [],
+      status: (PROPOSAL_STATUSES.has(statusRaw) ? statusRaw : "Active") as GovernanceProposalStatus,
+      createdAt: Number(scValToBigInt(field("created_at") ?? xdr.ScVal.scvU64(0))),
+      expiresAt: Number(scValToBigInt(field("expires_at") ?? xdr.ScVal.scvU64(0))),
+    }
+  } catch {
+    return null
+  }
+}
+
+export async function fetchGovernanceQuorum(govContractId: string): Promise<number | null> {
+  if (!govContractId) return null
+  try {
+    const val = await viewCall(govContractId, "get_voting_quorum")
+    return val.switch().name === "scvU32" ? val.u32() : null
+  } catch {
+    return null
+  }
+}
+
+export async function fetchActiveProposals(
+  govContractId: string,
+  poolContractId: string
+): Promise<GovernanceProposal[]> {
+  if (!govContractId || !poolContractId) return []
+  try {
+    const val = await viewCall(govContractId, "get_active_proposals", addressVal(poolContractId))
+    return (val.vec() ?? []).map(parseProposal).filter((p): p is GovernanceProposal => p !== null)
+  } catch {
+    return []
+  }
+}
+
+export async function fetchRecentProposals(govContractId: string): Promise<GovernanceProposal[]> {
+  if (!govContractId) return []
+  try {
+    const val = await viewCall(govContractId, "get_recent_proposals")
+    return (val.vec() ?? []).map(parseProposal).filter((p): p is GovernanceProposal => p !== null)
+  } catch {
+    return []
+  }
+}
+
+export function useCreateProposal(govContractId: string) {
+  const { address } = useStellar()
+  const [isLoading, setIsLoading] = useState(false)
+
+  const createProposal = async (
+    proposalType: string,
+    description: string,
+    params: Record<string, string>
+  ): Promise<string | undefined> => {
+    if (!address || !govContractId) return
+    setIsLoading(true)
+    try {
+      return await submitTx(address, (account) =>
+        new TransactionBuilder(account, {
+          fee: BASE_FEE,
+          networkPassphrase: STELLAR_NETWORK_PASSPHRASE,
+        })
+          .addOperation(
+            new Contract(normalizeId(govContractId)).call(
+              "create_proposal",
+              addressVal(address),
+              nativeToScVal(proposalType, { type: "symbol" }),
+              nativeToScVal(description, { type: "string" }),
+              governanceParamsVal(params)
+            )
+          )
+          .setTimeout(TX_TIMEOUT)
+          .build()
+      )
+    } finally {
+      setIsLoading(false)
+    }
+  }
+
+  return { createProposal, isLoading }
+}
+
+export function useGovernanceVote(govContractId: string) {
+  const { address } = useStellar()
+  const [isLoading, setIsLoading] = useState(false)
+
+  const vote = async (proposalIdHex: string, inFavor: boolean): Promise<string | undefined> => {
+    if (!address || !govContractId) return
+    setIsLoading(true)
+    try {
+      return await submitTx(address, (account) =>
+        new TransactionBuilder(account, {
+          fee: BASE_FEE,
+          networkPassphrase: STELLAR_NETWORK_PASSPHRASE,
+        })
+          .addOperation(
+            new Contract(normalizeId(govContractId)).call(
+              "vote",
+              addressVal(address),
+              proposalIdVal(proposalIdHex),
+              boolVal(inFavor)
+            )
+          )
+          .setTimeout(TX_TIMEOUT)
+          .build()
+      )
+    } finally {
+      setIsLoading(false)
+    }
+  }
+
+  return { vote, isLoading }
+}
+
+export function useExecuteProposal(govContractId: string) {
+  const { address } = useStellar()
+  const [isLoading, setIsLoading] = useState(false)
+
+  const executeProposal = async (proposalIdHex: string): Promise<string | undefined> => {
+    if (!address || !govContractId) return
+    setIsLoading(true)
+    try {
+      return await submitTx(address, (account) =>
+        new TransactionBuilder(account, {
+          fee: BASE_FEE,
+          networkPassphrase: STELLAR_NETWORK_PASSPHRASE,
+        })
+          .addOperation(
+            new Contract(normalizeId(govContractId)).call(
+              "execute_proposal",
+              addressVal(address),
+              proposalIdVal(proposalIdHex)
+            )
+          )
+          .setTimeout(TX_TIMEOUT)
+          .build()
+      )
+    } finally {
+      setIsLoading(false)
+    }
+  }
+
+  return { executeProposal, isLoading }
+}
diff --git a/frontend/lib/governance.test.ts b/frontend/lib/governance.test.ts
new file mode 100644
index 0000000..cb6a9c0
--- /dev/null
+++ b/frontend/lib/governance.test.ts
@@ -0,0 +1,93 @@
+// Unit tests for the governance domain helpers (issue #207)
+import { test } from "node:test"
+import assert from "node:assert"
+import {
+  decodeExecutionResult,
+  encodeParamHex,
+  formatTimeRemaining,
+  meetsQuorum,
+  mergeProposals,
+  votesNeededForQuorum,
+  type GovernanceProposal,
+} from "./governance"
+
+test("votesNeededForQuorum - rounds up to guarantee contract threshold", () => {
+  assert.strictEqual(votesNeededForQuorum(51, 3), 2)
+  assert.strictEqual(votesNeededForQuorum(50, 3), 2)
+  assert.strictEqual(votesNeededForQuorum(51, 100), 51)
+  assert.strictEqual(votesNeededForQuorum(66, 3), 2)
+})
+
+test("votesNeededForQuorum - degenerate inputs", () => {
+  assert.strictEqual(votesNeededForQuorum(0, 5), 0)
+  assert.strictEqual(votesNeededForQuorum(51, 0), 0)
+  assert.strictEqual(votesNeededForQuorum(NaN, 5), 0)
+})
+
+test("meetsQuorum - matches contract votes*100 >= quorum*total check", () => {
+  assert.strictEqual(meetsQuorum(2, 51, 3), true)
+  assert.strictEqual(meetsQuorum(1, 51, 3), false)
+  assert.strictEqual(meetsQuorum(0, 51, 3), false)
+  assert.strictEqual(meetsQuorum(1, 50, 2), true)
+})
+
+test("formatTimeRemaining - buckets", () => {
+  const now = 10_000
+  assert.strictEqual(formatTimeRemaining(now + 3600 * 23 + 60 * 12, now), "23h 12m")
+  assert.strictEqual(formatTimeRemaining(now + 60 * 5, now), "5m")
+  assert.strictEqual(formatTimeRemaining(now + 30, now), "<1m")
+  assert.strictEqual(formatTimeRemaining(now - 1, now), "Expired")
+  assert.strictEqual(formatTimeRemaining(now, now), "Expired")
+})
+
+test("encodeParamHex - produces exactly 16 big-endian bytes", () => {
+  assert.strictEqual(encodeParamHex(500), "000000000000000000000000000001f4")
+  assert.strictEqual(encodeParamHex(0), "00000000000000000000000000000000")
+  assert.strictEqual(
+    encodeParamHex(BigInt("340282366920938463463374607431768211455")),
+    "ffffffffffffffffffffffffffffffff"
+  )
+})
+
+test("encodeParamHex - rejects negatives and overflow", () => {
+  assert.throws(() => encodeParamHex(-1))
+  assert.throws(() => encodeParamHex(1n << 128n))
+})
+
+test("decodeExecutionResult - round trips utf8 payload", () => {
+  const hex = Buffer.from("quorum=66", "utf8").toString("hex")
+  assert.strictEqual(decodeExecutionResult(hex), "quorum=66")
+  assert.strictEqual(decodeExecutionResult(""), "")
+  assert.strictEqual(decodeExecutionResult("zz"), "")
+})
+
+function proposal(id: string, status: GovernanceProposal["status"], createdAt: number) {
+  return {
+    id,
+    proposer: "GPROPOSER",
+    proposalType: "ChangeDepositAmount",
+    description: "d",
+    votesFor: [],
+    votesAgainst: [],
+    status,
+    createdAt,
+    expiresAt: createdAt + 172_800,
+  } as GovernanceProposal
+}
+
+test("mergeProposals - dedupes by id and orders active before terminal states", () => {
+  const merged = mergeProposals(
+    [proposal("aaa", "Active", 300)],
+    [
+      proposal("bbb", "Executed", 200),
+      proposal("ccc", "Rejected", 400),
+      proposal("aaa", "Active", 300),
+      proposal("ddd", "Passed", 350),
+      proposal("eee", "Expired", 500),
+    ]
+  )
+  assert.deepStrictEqual(
+    merged.map((p) => p.id),
+    ["aaa", "ddd", "bbb", "ccc", "eee"]
+  )
+})
diff --git a/frontend/lib/governance.ts b/frontend/lib/governance.ts
new file mode 100644
index 0000000..9f93ef0
--- /dev/null
+++ b/frontend/lib/governance.ts
@@ -0,0 +1,135 @@
+// Pure governance-domain helpers shared by the hooks, components and tests.
+// Kept framework-free so it can be unit-tested with the node test runner.
+
+export type GovernanceProposalStatus = "Active" | "Passed" | "Executed" | "Expired" | "Rejected"
+
+export type GovernanceProposalType =
+  | "ChangeDepositAmount"
+  | "ExtendDeadline"
+  | "AddPenalty"
+  | "RemovePenalty"
+  | "ChangeQuorum"
+  | "Custom"
+
+export interface GovernanceProposal {
+  id: string
+  proposer: string
+  proposalType: GovernanceProposalType
+  description: string
+  votesFor: string[]
+  votesAgainst: string[]
+  status: GovernanceProposalStatus
+  createdAt: number
+  expiresAt: number
+}
+
+/** Metadata driving the create-proposal dialog's dynamic form fields. */
+export const PROPOSAL_TYPES: Array<{
+  value: GovernanceProposalType
+  label: string
+  paramKey: string
+  paramLabel: string
+}> = [
+  {
+    value: "ChangeDepositAmount",
+    label: "Change Deposit Amount",
+    paramKey: "deposit_amount",
+    paramLabel: "New deposit amount",
+  },
+  {
+    value: "ExtendDeadline",
+    label: "Extend Deadline",
+    paramKey: "seconds",
+    paramLabel: "Extension (seconds)",
+  },
+  {
+    value: "AddPenalty",
+    label: "Add Penalty",
+    paramKey: "percentage",
+    paramLabel: "Penalty percentage (0-100)",
+  },
+  {
+    value: "RemovePenalty",
+    label: "Remove Penalty",
+    paramKey: "",
+    paramLabel: "",
+  },
+  {
+    value: "ChangeQuorum",
+    label: "Change Quorum",
+    paramKey: "quorum",
+    paramLabel: "New quorum percentage (1-100)",
+  },
+]
+
+export const GOVERNANCE_DESCRIPTION_MAX = 500
+
+/**
+ * Minimum "for" votes required to meet the quorum percentage of the pool.
+ * Mirrors the contract check: votes * 100 >= quorumPct * totalMembers.
+ */
+export function votesNeededForQuorum(quorumPct: number, totalMembers: number): number {
+  if (!Number.isFinite(quorumPct) || !Number.isFinite(totalMembers)) return 0
+  if (quorumPct <= 0 || totalMembers <= 0) return 0
+  return Math.ceil((quorumPct * totalMembers) / 100)
+}
+
+export function meetsQuorum(votesFor: number, quorumPct: number, totalMembers: number): boolean {
+  if (votesFor <= 0) return false
+  return votesFor >= votesNeededForQuorum(quorumPct, totalMembers)
+}
+
+/** Human-readable time left before a proposal expires ("23h 12m"). */
+export function formatTimeRemaining(expiresAtSecs: number, nowSecs: number): string {
+  const diff = expiresAtSecs - nowSecs
+  if (diff <= 0) return "Expired"
+  const hours = Math.floor(diff / 3600)
+  const minutes = Math.floor((diff % 3600) / 60)
+  if (hours > 0) return `${hours}h ${minutes.toString().padStart(2, "0")}m`
+  if (minutes > 0) return `${minutes}m`
+  return "<1m"
+}
+
+/**
+ * Encode an i128 parameter as exactly 16 bytes of big-endian hex — the wire
+ * format the governance contract expects inside its parameters map.
+ */
+export function encodeParamHex(value: bigint | number): string {
+  const v = typeof value === "bigint" ? value : BigInt(Math.trunc(value))
+  if (v < 0n) throw new Error("parameter must be non-negative")
+  if (v >= 1n << 128n) throw new Error("parameter exceeds i128 range")
+  return v.toString(16).padStart(32, "0")
+}
+
+/** Decode a hex-encoded execution result payload written by the contract. */
+export function decodeExecutionResult(hex: string): string {
+  if (!hex || /[^0-9a-fA-F]/.test(hex) || hex.length % 2 !== 0) return ""
+  const pairs = hex.match(/.{2}/g) ?? []
+  return Buffer.from(pairs.map((b) => parseInt(b, 16))).toString("utf8")
+}
+
+const STATUS_ORDER: Record<GovernanceProposalStatus, number> = {
+  Active: 0,
+  Passed: 1,
+  Executed: 2,
+  Rejected: 3,
+  Expired: 4,
+}
+
+/**
+ * Merge active + recent proposals into one deduplicated feed ordered by
+ * lifecycle priority then newest first.
+ */
+export function mergeProposals(
+  active: GovernanceProposal[],
+  recent: GovernanceProposal[]
+): GovernanceProposal[] {
+  const byId = new Map<string, GovernanceProposal>()
+  for (const p of recent) byId.set(p.id, p)
+  for (const p of active) byId.set(p.id, p)
+  return [...byId.values()].sort((a, b) => {
+    const statusDiff = STATUS_ORDER[a.status] - STATUS_ORDER[b.status]
+    if (statusDiff !== 0) return statusDiff
+    return b.createdAt - a.createdAt || (a.id < b.id ? -1 : 1)
+  })
+}
diff --git a/frontend/messages/en.json b/frontend/messages/en.json
index 69e2396..3bd4381 100644
--- a/frontend/messages/en.json
+++ b/frontend/messages/en.json
@@ -1846,5 +1846,57 @@
       "markedDefaulted": "Loan marked as defaulted — reputation penalty applied",
       "defaultFailed": "Failed to default loan"
     }
+  },
+  "governance": {
+    "title": "Governance",
+    "subtitle": "Pool parameters are decided collectively by members.",
+    "quorumInfo": "{needed} of {total} members must vote For to meet the {quorum}% quorum",
+    "membersCount": "{total} members",
+    "createProposal": "New Proposal",
+    "emptyState": "No active proposals",
+    "emptyHint": "Start a proposal to change how this pool works.",
+    "recentTitle": "Recent proposals",
+    "showRecent": "Show recent",
+    "hideRecent": "Hide recent",
+    "votesFor": "For",
+    "votesAgainst": "Against",
+    "timeLeft": "Ends in {time}",
+    "voteFor": "Vote For",
+    "voteAgainst": "Vote Against",
+    "execute": "Execute",
+    "voting": "Voting...",
+    "executing": "Executing...",
+    "alreadyVoted": "You already voted",
+    "ownProposal": "You cannot vote on your own proposal",
+    "notMember": "Only pool members can participate",
+    "closed": "Voting closed",
+    "typeLabel": "Proposal type",
+    "descriptionLabel": "Description",
+    "descriptionPlaceholder": "Describe the change you want to make...",
+    "paramLabel": "Value",
+    "submit": "Submit Proposal",
+    "submitting": "Submitting...",
+    "cancel": "Cancel",
+    "charCount": "{count}/{max}",
+    "fillRequired": "Fill in all required fields",
+    "toastCreated": "Proposal submitted",
+    "toastVoteRecorded": "Vote recorded on-chain",
+    "toastExecuted": "Proposal executed",
+    "toastError": "Transaction failed. Please try again.",
+    "statuses": {
+      "Active": "Active",
+      "Passed": "Passed",
+      "Executed": "Executed",
+      "Expired": "Expired",
+      "Rejected": "Rejected"
+    },
+    "types": {
+      "ChangeDepositAmount": "Change Deposit Amount",
+      "ExtendDeadline": "Extend Deadline",
+      "AddPenalty": "Add Penalty",
+      "RemovePenalty": "Remove Penalty",
+      "ChangeQuorum": "Change Quorum",
+      "Custom": "Custom"
+    }
   }
 }
diff --git a/frontend/messages/es.json b/frontend/messages/es.json
index 7b94355..b1dab2b 100644
--- a/frontend/messages/es.json
+++ b/frontend/messages/es.json
@@ -1854,5 +1854,57 @@
       "markedDefaulted": "Préstamo marcado como incumplido — penalización de reputación aplicada",
       "defaultFailed": "Error al marcar el préstamo como incumplido"
     }
+  },
+  "governance": {
+    "title": "Gobernanza",
+    "subtitle": "Los parámetros del grupo se deciden colectivamente entre los miembros.",
+    "quorumInfo": "{needed} de {total} miembros deben votar A Favor para alcanzar el quórum del {quorum}%",
+    "membersCount": "{total} miembros",
+    "createProposal": "Nueva Propuesta",
+    "emptyState": "No hay propuestas activas",
+    "emptyHint": "Inicia una propuesta para cambiar cómo funciona este grupo.",
+    "recentTitle": "Propuestas recientes",
+    "showRecent": "Mostrar recientes",
+    "hideRecent": "Ocultar recientes",
+    "votesFor": "A favor",
+    "votesAgainst": "En contra",
+    "timeLeft": "Termina en {time}",
+    "voteFor": "Votar a favor",
+    "voteAgainst": "Votar en contra",
+    "execute": "Ejecutar",
+    "voting": "Votando...",
+    "executing": "Ejecutando...",
+    "alreadyVoted": "Ya votaste",
+    "ownProposal": "No puedes votar tu propia propuesta",
+    "notMember": "Solo los miembros pueden participar",
+    "closed": "Votación cerrada",
+    "typeLabel": "Tipo de propuesta",
+    "descriptionLabel": "Descripción",
+    "descriptionPlaceholder": "Describe el cambio que quieres realizar...",
+    "paramLabel": "Valor",
+    "submit": "Enviar propuesta",
+    "submitting": "Enviando...",
+    "cancel": "Cancelar",
+    "charCount": "{count}/{max}",
+    "fillRequired": "Completa todos los campos obligatorios",
+    "toastCreated": "Propuesta enviada",
+    "toastVoteRecorded": "Voto registrado en la blockchain",
+    "toastExecuted": "Propuesta ejecutada",
+    "toastError": "La transacción falló. Inténtalo de nuevo.",
+    "statuses": {
+      "Active": "Activa",
+      "Passed": "Aprobada",
+      "Executed": "Ejecutada",
+      "Expired": "Expirada",
+      "Rejected": "Rechazada"
+    },
+    "types": {
+      "ChangeDepositAmount": "Cambiar monto de depósito",
+      "ExtendDeadline": "Extender plazo",
+      "AddPenalty": "Agregar penalización",
+      "RemovePenalty": "Quitar penalización",
+      "ChangeQuorum": "Cambiar quórum",
+      "Custom": "Personalizada"
+    }
   }
 }
diff --git a/smartcontract/Cargo.lock b/smartcontract/Cargo.lock
index b27f612..107ae56 100644
--- a/smartcontract/Cargo.lock
+++ b/smartcontract/Cargo.lock
@@ -689,6 +689,13 @@ dependencies = [
  "soroban-sdk",
 ]
 
+[[package]]
+name = "jointsave-governance"
+version = "0.1.0"
+dependencies = [
+ "soroban-sdk",
+]
+
 [[package]]
 name = "jointsave-microloan"
 version = "0.1.0"
diff --git a/smartcontract/Cargo.toml b/smartcontract/Cargo.toml
index 5e7a2d6..ba659f1 100644
--- a/smartcontract/Cargo.toml
+++ b/smartcontract/Cargo.toml
@@ -7,6 +7,7 @@ members = [
     "contracts/yield-strategy",
     "contracts/reputation",
     "contracts/microloan",
+    "contracts/governance",
     "migration",
 ]
 resolver = "2"
diff --git a/smartcontract/contracts/flexible/src/lib.rs b/smartcontract/contracts/flexible/src/lib.rs
index dda229f..0147fee 100644
--- a/smartcontract/contracts/flexible/src/lib.rs
+++ b/smartcontract/contracts/flexible/src/lib.rs
@@ -28,6 +28,10 @@ pub enum DataKey {
     ReputationTracker,
     /// Optional allowlist of accepted token addresses (empty = unrestricted).
     SupportedTokens,
+    /// Optional address of the attached DAO governance contract.
+    GovernanceContract,
+    /// Late/missed-deposit penalty percentage governable by the DAO (0-100).
+    PenaltyPercentage,
 }
 
 const LEDGER_THRESHOLD: u32 = 518400;
@@ -519,6 +523,12 @@ impl FlexiblePool {
         if storage.has(&DataKey::SupportedTokens) {
             storage.extend_ttl(&DataKey::SupportedTokens, LEDGER_THRESHOLD, LEDGER_BUMP);
         }
+        if storage.has(&DataKey::GovernanceContract) {
+            storage.extend_ttl(&DataKey::GovernanceContract, LEDGER_THRESHOLD, LEDGER_BUMP);
+        }
+        if storage.has(&DataKey::PenaltyPercentage) {
+            storage.extend_ttl(&DataKey::PenaltyPercentage, LEDGER_THRESHOLD, LEDGER_BUMP);
+        }
     }
 
     /// Point this pool at a deployed ReputationTracker contract so deposits
@@ -533,6 +543,66 @@ impl FlexiblePool {
         Self::bump_config_state_internal(&env);
     }
 
+    // ── DAO governance ────────────────────────────────────────────────────
+
+    /// Register the DAO governance contract allowed to apply proposals.
+    pub fn set_governance_contract(env: Env, admin: Address, governance: Address) {
+        admin.require_auth();
+        let storage = env.storage().persistent();
+        let stored_admin: Address = storage.get(&DataKey::Admin).unwrap();
+        assert!(admin == stored_admin, "not admin");
+
+        storage.set(&DataKey::GovernanceContract, &governance);
+        Self::bump_config_state_internal(&env);
+
+        env.events()
+            .publish((symbol_short!("gov_set"), admin), governance);
+    }
+
+    /// Apply a governance-approved parameter change. Callable by the pool
+    /// admin directly or by the registered governance contract via CPI.
+    ///
+    /// Proposal types (symbols):
+    ///   - "change_deposit_amount" -> minimum deposit in stroops (> 0)
+    ///   - "add_penalty"           -> penalty percentage 0-100
+    ///   - "remove_penalty"        -> clears penalty percentage
+    pub fn apply_governance_proposal(
+        env: Env,
+        caller: Address,
+        proposal_type: Symbol,
+        new_value: i128,
+    ) {
+        caller.require_auth();
+        let storage = env.storage().persistent();
+        let stored_admin: Address = storage.get(&DataKey::Admin).unwrap();
+        let gov: Option<Address> = storage.get(&DataKey::GovernanceContract);
+        assert!(
+            caller == stored_admin || gov.map_or(false, |g| g == caller),
+            "not authorized"
+        );
+
+        let change_deposit = Symbol::new(&env, "change_deposit_amount");
+        let add_penalty = Symbol::new(&env, "add_penalty");
+        let remove_penalty = Symbol::new(&env, "remove_penalty");
+
+        if proposal_type == change_deposit {
+            assert!(new_value > 0, "minimum must be > 0");
+            storage.set(&DataKey::MinimumDeposit, &new_value);
+        } else if proposal_type == add_penalty {
+            assert!(new_value >= 0 && new_value <= 100, "penalty must be 0-100");
+            storage.set(&DataKey::PenaltyPercentage, &(new_value as u32));
+        } else if proposal_type == remove_penalty {
+            storage.set(&DataKey::PenaltyPercentage, &0u32);
+        } else {
+            panic!("unsupported proposal type");
+        }
+
+        Self::bump_config_state_internal(&env);
+
+        env.events()
+            .publish((symbol_short!("gov_appl"), proposal_type), new_value);
+    }
+
     // ── Views ─────────────────────────────────────────────────────────────
 
     pub fn get_version(_env: Env) -> u32 {
@@ -613,6 +683,27 @@ impl FlexiblePool {
             .unwrap_or(Vec::new(&env))
     }
 
+    /// Address of the attached DAO governance contract, if any.
+    pub fn governance_contract(env: Env) -> Option<Address> {
+        env.storage().persistent().get(&DataKey::GovernanceContract)
+    }
+
+    /// Current minimum deposit in stroops.
+    pub fn minimum_deposit(env: Env) -> i128 {
+        env.storage()
+            .persistent()
+            .get(&DataKey::MinimumDeposit)
+            .unwrap_or(0)
+    }
+
+    /// Penalty percentage applied to missed deposits (0 by default).
+    pub fn penalty_percentage(env: Env) -> u32 {
+        env.storage()
+            .persistent()
+            .get(&DataKey::PenaltyPercentage)
+            .unwrap_or(0)
+    }
+
     // ── Helpers ───────────────────────────────────────────────────────────
 
     /// If a supported-token allowlist has been configured, require `token` to
diff --git a/smartcontract/contracts/flexible/src/tests.rs b/smartcontract/contracts/flexible/src/tests.rs
index 5df5efc..9f6a4e5 100644
--- a/smartcontract/contracts/flexible/src/tests.rs
+++ b/smartcontract/contracts/flexible/src/tests.rs
@@ -3,7 +3,7 @@
 use super::{FlexiblePool, FlexiblePoolClient};
 use soroban_sdk::{
     testutils::{storage::Persistent, Address as _, Ledger as _},
-    token, Address, Env, Vec,
+    token, Address, Env, Symbol, Vec,
 };
 
 fn setup_pool(
@@ -709,3 +709,57 @@ mod mock_strategy {
 }
 
 pub use mock_strategy::MockStrategy;
+
+// ── DAO governance integration ───────────────────────────────────────────────
+
+#[test]
+fn governance_contract_can_change_minimum_deposit() {
+    let env = Env::default();
+    env.mock_all_auths();
+    let (client, _token, admin, _treasury, _a, _b) = setup_pool(&env, false);
+
+    let gov = Address::generate(&env);
+    client.set_governance_contract(&admin, &gov);
+    assert_eq!(client.governance_contract(), Some(gov.clone()));
+
+    client.apply_governance_proposal(&gov, &Symbol::new(&env, "change_deposit_amount"), &50i128);
+    assert_eq!(client.minimum_deposit(), 50i128);
+}
+
+#[test]
+fn admin_can_apply_governance_proposals_directly() {
+    let env = Env::default();
+    env.mock_all_auths();
+    let (client, _token, admin, _treasury, _a, _b) = setup_pool(&env, false);
+
+    client.apply_governance_proposal(&admin, &Symbol::new(&env, "add_penalty"), &10i128);
+    assert_eq!(client.penalty_percentage(), 10u32);
+
+    client.apply_governance_proposal(&admin, &Symbol::new(&env, "remove_penalty"), &0i128);
+    assert_eq!(client.penalty_percentage(), 0u32);
+}
+
+#[test]
+#[should_panic(expected = "not authorized")]
+fn unauthorized_caller_cannot_apply_proposal() {
+    let env = Env::default();
+    env.mock_all_auths();
+    let (client, _token, admin, _treasury, _a, _b) = setup_pool(&env, false);
+
+    let impostor = Address::generate(&env);
+    client.apply_governance_proposal(
+        &impostor,
+        &Symbol::new(&env, "change_deposit_amount"),
+        &50i128,
+    );
+}
+
+#[test]
+#[should_panic(expected = "not admin")]
+fn non_admin_cannot_register_governance_contract() {
+    let env = Env::default();
+    env.mock_all_auths();
+    let (client, _token, _admin, _treasury, member_a, _b) = setup_pool(&env, false);
+
+    client.set_governance_contract(&member_a, &Address::generate(&env));
+}
diff --git a/smartcontract/contracts/flexible/test_snapshots/tests/test_set_yield_strategy_requires_yield_enabled.1.json b/smartcontract/contracts/flexible/test_snapshots/tests/test_set_yield_strategy_requires_yield_enabled.1.json
index c6e3155..0b382c4 100644
--- a/smartcontract/contracts/flexible/test_snapshots/tests/test_set_yield_strategy_requires_yield_enabled.1.json
+++ b/smartcontract/contracts/flexible/test_snapshots/tests/test_set_yield_strategy_requires_yield_enabled.1.json
@@ -1085,7 +1085,7 @@
             "data": {
               "vec": [
                 {
-                  "string": "caught panic 'yield disabled' from contract function 'Symbol(obj#205)'"
+                  "string": "caught panic 'yield disabled' from contract function 'Symbol(obj#217)'"
                 },
                 {
                   "address": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAITA4"
diff --git a/smartcontract/contracts/governance/Cargo.toml b/smartcontract/contracts/governance/Cargo.toml
new file mode 100644
index 0000000..c3dcdc1
--- /dev/null
+++ b/smartcontract/contracts/governance/Cargo.toml
@@ -0,0 +1,13 @@
+[package]
+name = "jointsave-governance"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+soroban-sdk = { version = "21.0.0", features = ["alloc"] }
+
+[dev-dependencies]
+soroban-sdk = { version = "21.0.0", features = ["testutils", "alloc"] }
diff --git a/smartcontract/contracts/governance/src/lib.rs b/smartcontract/contracts/governance/src/lib.rs
new file mode 100644
index 0000000..f5864ee
--- /dev/null
+++ b/smartcontract/contracts/governance/src/lib.rs
@@ -0,0 +1,644 @@
+#![no_std]
+
+use soroban_sdk::{
+    contract, contractimpl, contracttype, symbol_short, Address, Bytes, BytesN, Env, IntoVal, Map,
+    String, Symbol, Vec,
+};
+
+const VERSION: u32 = 1;
+
+const MAX_ACTIVE_PROPOSALS: u32 = 3;
+const MAX_RECENT_PROPOSALS: u32 = 50;
+const DEFAULT_VOTING_PERIOD_SECS: u64 = 48 * 60 * 60;
+
+const LEDGER_THRESHOLD: u32 = 518400;
+const LEDGER_BUMP: u32 = 2592000;
+
+#[contracttype]
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum ProposalType {
+    ChangeDepositAmount,
+    ExtendDeadline,
+    AddPenalty,
+    RemovePenalty,
+    ChangeQuorum,
+    Custom,
+}
+
+#[contracttype]
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum ProposalStatus {
+    Active,
+    Passed,
+    Executed,
+    Expired,
+    Rejected,
+}
+
+#[contracttype]
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct Proposal {
+    pub id: BytesN<32>,
+    pub proposer: Address,
+    pub proposal_type: ProposalType,
+    pub description: String,
+    pub parameters: Map<String, Bytes>,
+    pub votes_for: Vec<Address>,
+    pub votes_against: Vec<Address>,
+    pub status: ProposalStatus,
+    pub created_at: u64,
+    pub expires_at: u64,
+    pub execution_result: Option<Bytes>,
+}
+
+#[contracttype]
+pub enum DataKey {
+    Admin,
+    PoolContract,
+    VotingQuorum,
+    ProposalCount,
+    Proposal(BytesN<32>),
+    ActiveProposals,
+    RecentProposals,
+    Vote(BytesN<32>, Address),
+}
+
+#[contract]
+pub struct Governance;
+
+fn voting_period() -> u64 {
+    DEFAULT_VOTING_PERIOD_SECS
+}
+
+#[contractimpl]
+impl Governance {
+    /// Attach this governance contract to a pool. The quorum is expressed as a
+    /// percentage of total pool members (e.g. 51 means 51% must vote in favor).
+    pub fn initialize(env: Env, admin: Address, pool_contract: Address, voting_quorum: u32) {
+        admin.require_auth();
+
+        let storage = env.storage().persistent();
+        assert!(!storage.has(&DataKey::Admin), "already initialized");
+        assert!((1..=100).contains(&voting_quorum), "quorum must be 1-100");
+
+        storage.set(&DataKey::Admin, &admin);
+        storage.set(&DataKey::PoolContract, &pool_contract);
+        storage.set(&DataKey::VotingQuorum, &voting_quorum);
+        storage.set(&DataKey::ProposalCount, &0u64);
+        storage.set(&DataKey::ActiveProposals, &Vec::<BytesN<32>>::new(&env));
+        storage.set(&DataKey::RecentProposals, &Vec::<BytesN<32>>::new(&env));
+
+        Self::bump_config_state_internal(&env);
+
+        env.events()
+            .publish((symbol_short!("gov_init"), pool_contract), voting_quorum);
+    }
+
+    /// Admin override for the quorum percentage (governance itself can also
+    /// change it via a ChangeQuorum proposal).
+    pub fn set_voting_quorum(env: Env, admin: Address, voting_quorum: u32) {
+        admin.require_auth();
+        let storage = env.storage().persistent();
+        let stored_admin: Address = storage.get(&DataKey::Admin).unwrap();
+        assert!(admin == stored_admin, "not admin");
+        assert!((1..=100).contains(&voting_quorum), "quorum must be 1-100");
+
+        storage.set(&DataKey::VotingQuorum, &voting_quorum);
+        Self::bump_config_state_internal(&env);
+
+        env.events()
+            .publish((symbol_short!("quorum"),), voting_quorum);
+    }
+
+    /// Create a new proposal. Only current members of the attached pool may
+    /// propose; at most `MAX_ACTIVE_PROPOSALS` proposals can be open at once.
+    ///
+    /// Parameters are serialized per proposal type as big-endian i128 values
+    /// under well-known keys:
+    ///   - ChangeDepositAmount -> "deposit_amount"
+    ///   - ExtendDeadline      -> "seconds"
+    ///   - AddPenalty          -> "percentage"
+    ///   - RemovePenalty       -> (no parameter required)
+    ///   - ChangeQuorum        -> "quorum"
+    ///   - Custom              -> free-form
+    pub fn create_proposal(
+        env: Env,
+        proposer: Address,
+        proposal_type: ProposalType,
+        description: String,
+        parameters: Map<String, Bytes>,
+    ) -> BytesN<32> {
+        proposer.require_auth();
+        Self::assert_pool_member(&env, &proposer);
+        assert!(!description.is_empty(), "description required");
+        assert!(description.len() <= 500, "description too long");
+
+        let storage = env.storage().persistent();
+        let active: Vec<BytesN<32>> = storage.get(&DataKey::ActiveProposals).unwrap();
+        assert!(
+            active.len() < MAX_ACTIVE_PROPOSALS,
+            "too many active proposals"
+        );
+        assert!(
+            !(proposal_type == ProposalType::Custom && parameters.is_empty()),
+            "custom proposal requires parameters"
+        );
+
+        let count: u64 = storage.get(&DataKey::ProposalCount).unwrap_or(0) + 1;
+        let id = Self::proposal_id(&env, env.ledger().timestamp(), count);
+        let created_at = env.ledger().timestamp();
+        let expires_at = created_at + voting_period();
+
+        let proposal = Proposal {
+            id: id.clone(),
+            proposer: proposer.clone(),
+            proposal_type,
+            description,
+            parameters,
+            votes_for: Vec::new(&env),
+            votes_against: Vec::new(&env),
+            status: ProposalStatus::Active,
+            created_at,
+            expires_at,
+            execution_result: None,
+        };
+
+        storage.set(&DataKey::ProposalCount, &count);
+        storage.set(&DataKey::Proposal(id.clone()), &proposal);
+
+        let mut active: Vec<BytesN<32>> = active;
+        active.push_back(id.clone());
+        storage.set(&DataKey::ActiveProposals, &active);
+
+        let mut recent: Vec<BytesN<32>> = storage.get(&DataKey::RecentProposals).unwrap();
+        recent.push_back(id.clone());
+        if recent.len() > MAX_RECENT_PROPOSALS {
+            recent.remove(0);
+        }
+        storage.set(&DataKey::RecentProposals, &recent);
+
+        Self::bump_proposal_state_internal(&env, &id);
+        Self::bump_config_state_internal(&env);
+
+        env.events().publish(
+            (symbol_short!("prop_new"), proposer),
+            (id.clone(), created_at, expires_at),
+        );
+
+        id
+    }
+
+    /// Cast a vote. One vote per member per proposal; the proposer cannot vote
+    /// on their own proposal. If enough members vote against (same threshold
+    /// as the pass quorum), the proposal is rejected immediately.
+    pub fn vote(env: Env, voter: Address, proposal_id: BytesN<32>, in_favor: bool) {
+        voter.require_auth();
+        Self::assert_pool_member(&env, &voter);
+
+        let storage = env.storage().persistent();
+        let mut proposal: Proposal = storage
+            .get(&DataKey::Proposal(proposal_id.clone()))
+            .unwrap();
+
+        assert!(
+            env.ledger().timestamp() < proposal.expires_at,
+            "proposal expired"
+        );
+        assert_eq!(proposal.status, ProposalStatus::Active, "not active");
+        assert!(voter != proposal.proposer, "proposer cannot vote");
+        assert!(
+            !storage.has(&DataKey::Vote(proposal_id.clone(), voter.clone())),
+            "already voted"
+        );
+
+        storage.set(
+            &DataKey::Vote(proposal_id.clone(), voter.clone()),
+            &in_favor,
+        );
+
+        if in_favor {
+            proposal.votes_for.push_back(voter.clone());
+        } else {
+            proposal.votes_against.push_back(voter.clone());
+        }
+
+        let total_members = Self::pool_member_count(&env);
+        let quorum = Self::get_voting_quorum(env.clone());
+        let for_votes = proposal.votes_for.len();
+        let against_votes = proposal.votes_against.len();
+
+        // Quorum reached on the "against" side rejects the proposal outright.
+        if !in_favor && Self::meets_quorum(against_votes as u128, quorum, total_members as u128) {
+            Self::remove_from_active(&env, &proposal_id);
+            proposal.status = ProposalStatus::Rejected;
+            storage.set(&DataKey::Proposal(proposal_id.clone()), &proposal);
+            Self::bump_config_state_internal(&env);
+            env.events()
+                .publish((symbol_short!("prop_rej"), proposal_id), against_votes);
+            return;
+        }
+
+        if Self::meets_quorum(for_votes as u128, quorum, total_members as u128)
+            && proposal.status == ProposalStatus::Active
+        {
+            proposal.status = ProposalStatus::Passed;
+        }
+
+        storage.set(&DataKey::Proposal(proposal_id.clone()), &proposal);
+        Self::bump_proposal_state_internal(&env, &proposal_id);
+        Self::bump_config_state_internal(&env);
+
+        env.events().publish(
+            (symbol_short!("vote_cast"), voter),
+            (proposal_id.clone(), in_favor, for_votes, against_votes),
+        );
+    }
+
+    /// Execute a passed proposal. Requires the voting window to still be open
+    /// and the "for" quorum to be met. Applies the change to the target pool
+    /// via a cross-contract call to `apply_governance_proposal`.
+    pub fn execute_proposal(env: Env, executor: Address, proposal_id: BytesN<32>) {
+        executor.require_auth();
+        Self::assert_pool_member(&env, &executor);
+
+        let storage = env.storage().persistent();
+        let mut proposal: Proposal = storage
+            .get(&DataKey::Proposal(proposal_id.clone()))
+            .unwrap();
+
+        assert!(proposal.status == ProposalStatus::Passed, "quorum not met");
+        assert!(
+            env.ledger().timestamp() < proposal.expires_at,
+            "proposal expired"
+        );
+
+        let result = Self::dispatch(&env, &proposal);
+
+        Self::remove_from_active(&env, &proposal_id);
+        proposal.status = ProposalStatus::Executed;
+        proposal.execution_result = Some(result);
+        storage.set(&DataKey::Proposal(proposal_id.clone()), &proposal);
+        Self::bump_config_state_internal(&env);
+
+        env.events()
+            .publish((symbol_short!("prop_exec"), proposal_id), ());
+    }
+
+    /// Finalize a proposal whose voting window has closed without execution.
+    /// Expired proposals are terminal and can no longer be voted on.
+    pub fn expire_proposal(env: Env, executor: Address, proposal_id: BytesN<32>) {
+        executor.require_auth();
+        Self::assert_pool_member(&env, &executor);
+
+        let storage = env.storage().persistent();
+        let mut proposal: Proposal = storage
+            .get(&DataKey::Proposal(proposal_id.clone()))
+            .unwrap();
+
+        assert!(
+            env.ledger().timestamp() >= proposal.expires_at,
+            "voting period not over"
+        );
+        assert!(
+            proposal.status == ProposalStatus::Active || proposal.status == ProposalStatus::Passed,
+            "already finalized"
+        );
+
+        Self::mark_expired(&env, &mut proposal);
+    }
+
+    // ── Views ─────────────────────────────────────────────────────────────
+
+    pub fn get_version(_env: Env) -> u32 {
+        VERSION
+    }
+
+    pub fn get_proposal(env: Env, proposal_id: BytesN<32>) -> Proposal {
+        env.storage()
+            .persistent()
+            .get(&DataKey::Proposal(proposal_id))
+            .unwrap()
+    }
+
+    pub fn has_voted(env: Env, proposal_id: BytesN<32>, voter: Address) -> Option<bool> {
+        env.storage()
+            .persistent()
+            .get(&DataKey::Vote(proposal_id, voter))
+    }
+
+    /// All proposals currently inside their voting window. The `pool_contract`
+    /// argument must match the pool this governance contract is attached to.
+    pub fn get_active_proposals(env: Env, pool_contract: Address) -> Vec<Proposal> {
+        let stored_pool: Address = env
+            .storage()
+            .persistent()
+            .get(&DataKey::PoolContract)
+            .unwrap();
+        assert!(pool_contract == stored_pool, "wrong pool");
+
+        let ids: Vec<BytesN<32>> = env
+            .storage()
+            .persistent()
+            .get(&DataKey::ActiveProposals)
+            .unwrap();
+        Self::load_proposals(&env, &ids)
+    }
+
+    /// Most recent proposals (executed, rejected, expired included).
+    pub fn get_recent_proposals(env: Env) -> Vec<Proposal> {
+        let ids: Vec<BytesN<32>> = env
+            .storage()
+            .persistent()
+            .get(&DataKey::RecentProposals)
+            .unwrap();
+        Self::load_proposals(&env, &ids)
+    }
+
+    pub fn get_voting_quorum(env: Env) -> u32 {
+        env.storage()
+            .persistent()
+            .get(&DataKey::VotingQuorum)
+            .unwrap_or(51)
+    }
+
+    pub fn voting_period_secs(_env: Env) -> u64 {
+        voting_period()
+    }
+
+    pub fn admin(env: Env) -> Address {
+        env.storage().persistent().get(&DataKey::Admin).unwrap()
+    }
+
+    pub fn pool_contract(env: Env) -> Address {
+        env.storage()
+            .persistent()
+            .get(&DataKey::PoolContract)
+            .unwrap()
+    }
+
+    pub fn bump_state(env: Env) {
+        Self::bump_config_state_internal(&env);
+        let recent: Vec<BytesN<32>> = env
+            .storage()
+            .persistent()
+            .get(&DataKey::RecentProposals)
+            .unwrap_or(Vec::new(&env));
+        for id in recent.iter() {
+            let key = DataKey::Proposal(id.clone());
+            if env.storage().persistent().has(&key) {
+                env.storage()
+                    .persistent()
+                    .extend_ttl(&key, LEDGER_THRESHOLD, LEDGER_BUMP);
+            }
+        }
+    }
+
+    /// Migrate this contract to a new version. Admin-only.
+    pub fn migrate(env: Env, admin: Address, to_version: u32) {
+        admin.require_auth();
+        let storage = env.storage().persistent();
+        let stored_admin: Address = storage.get(&DataKey::Admin).unwrap();
+        assert!(admin == stored_admin, "not admin");
+
+        let current = VERSION;
+        if to_version == current {
+            return;
+        }
+        assert!(
+            to_version == current + 1,
+            "version must be incremented by exactly 1"
+        );
+
+        env.events()
+            .publish((symbol_short!("migrated"), admin), to_version);
+    }
+
+    // ── Helpers ───────────────────────────────────────────────────────────
+
+    fn proposal_id(env: &Env, created_at: u64, count: u64) -> BytesN<32> {
+        let mut bytes = [0u8; 32];
+        bytes[..8].copy_from_slice(&created_at.to_be_bytes());
+        bytes[16..24].copy_from_slice(&count.to_be_bytes());
+        BytesN::from_array(env, &bytes)
+    }
+
+    fn meets_quorum(votes: u128, quorum_pct: u32, total_members: u128) -> bool {
+        if total_members == 0 {
+            return false;
+        }
+        votes.saturating_mul(100) >= (quorum_pct as u128).saturating_mul(total_members)
+    }
+
+    fn assert_pool_member(env: &Env, who: &Address) {
+        let pool: Address = env
+            .storage()
+            .persistent()
+            .get(&DataKey::PoolContract)
+            .unwrap();
+        let members: Vec<Address> =
+            env.invoke_contract(&pool, &symbol_short!("members"), soroban_sdk::vec![env]);
+        let mut found = false;
+        for m in members.iter() {
+            if m == *who {
+                found = true;
+                break;
+            }
+        }
+        assert!(found, "not a pool member");
+    }
+
+    fn pool_member_count(env: &Env) -> u32 {
+        let pool: Address = env
+            .storage()
+            .persistent()
+            .get(&DataKey::PoolContract)
+            .unwrap();
+        let members: Vec<Address> =
+            env.invoke_contract(&pool, &symbol_short!("members"), soroban_sdk::vec![env]);
+        members.len()
+    }
+
+    fn load_proposals(env: &Env, ids: &Vec<BytesN<32>>) -> Vec<Proposal> {
+        let mut out = Vec::new(env);
+        for id in ids.iter() {
+            if let Some(p) = env
+                .storage()
+                .persistent()
+                .get::<DataKey, Proposal>(&DataKey::Proposal(id.clone()))
+            {
+                out.push_back(p);
+            }
+        }
+        out
+    }
+
+    fn remove_from_active(env: &Env, proposal_id: &BytesN<32>) {
+        let storage = env.storage().persistent();
+        let active: Vec<BytesN<32>> = storage.get(&DataKey::ActiveProposals).unwrap();
+        let mut updated = Vec::new(env);
+        for id in active.iter() {
+            if id != *proposal_id {
+                updated.push_back(id);
+            }
+        }
+        storage.set(&DataKey::ActiveProposals, &updated);
+    }
+
+    fn mark_expired(env: &Env, proposal: &mut Proposal) {
+        let id = proposal.id.clone();
+        Self::remove_from_active(env, &id);
+        proposal.status = ProposalStatus::Expired;
+        env.storage()
+            .persistent()
+            .set(&DataKey::Proposal(id.clone()), proposal);
+        env.events().publish((symbol_short!("prop_exp"), id), ());
+    }
+
+    /// Apply the proposal: either update governance config directly or invoke
+    /// the pool contract's `apply_governance_proposal` entrypoint.
+    fn dispatch(env: &Env, proposal: &Proposal) -> Bytes {
+        let value_key = match proposal.proposal_type {
+            ProposalType::ChangeDepositAmount => "deposit_amount",
+            ProposalType::ExtendDeadline => "seconds",
+            ProposalType::AddPenalty => "percentage",
+            ProposalType::RemovePenalty => "",
+            ProposalType::ChangeQuorum => "quorum",
+            ProposalType::Custom => "",
+        };
+
+        let raw_value: Option<Bytes> = if !value_key.is_empty() {
+            let key = String::from_str(env, value_key);
+            let v = proposal.parameters.get(key);
+            assert!(v.is_some(), "missing parameter");
+            v
+        } else {
+            None
+        };
+
+        match proposal.proposal_type {
+            ProposalType::ChangeQuorum => {
+                let value = Self::require_i128(env, &raw_value);
+                assert!((1..=100).contains(&value), "quorum must be 1-100");
+                env.storage()
+                    .persistent()
+                    .set(&DataKey::VotingQuorum, &(value as u32));
+                format_result(env, "quorum", value)
+            }
+            ProposalType::RemovePenalty => {
+                let gov = env.current_contract_address();
+                let pool: Address = env
+                    .storage()
+                    .persistent()
+                    .get(&DataKey::PoolContract)
+                    .unwrap();
+                let _: () = env.invoke_contract(
+                    &pool,
+                    &Symbol::new(env, "apply_governance_proposal"),
+                    soroban_sdk::vec![
+                        env,
+                        gov.into_val(env),
+                        Symbol::new(env, "remove_penalty").into_val(env),
+                        0i128.into_val(env),
+                    ],
+                );
+                format_result(env, "penalty", 0)
+            }
+            ProposalType::Custom => {
+                let len = proposal.parameters.len();
+                format_result(env, "custom", len as i128)
+            }
+            _ => {
+                let value = Self::require_i128(env, &raw_value);
+                let type_symbol = match proposal.proposal_type {
+                    ProposalType::ChangeDepositAmount => "change_deposit_amount",
+                    ProposalType::ExtendDeadline => "extend_deadline",
+                    ProposalType::AddPenalty => "add_penalty",
+                    _ => unreachable!(),
+                };
+                let gov = env.current_contract_address();
+                let pool: Address = env
+                    .storage()
+                    .persistent()
+                    .get(&DataKey::PoolContract)
+                    .unwrap();
+                let _: () = env.invoke_contract(
+                    &pool,
+                    &Symbol::new(env, "apply_governance_proposal"),
+                    soroban_sdk::vec![
+                        env,
+                        gov.into_val(env),
+                        Symbol::new(env, type_symbol).into_val(env),
+                        value.into_val(env),
+                    ],
+                );
+                format_result(env, type_symbol, value)
+            }
+        }
+    }
+
+    fn require_i128(env: &Env, raw: &Option<Bytes>) -> i128 {
+        let bytes = raw.as_ref().expect("missing parameter");
+        assert!(bytes.len() == 16, "invalid parameter encoding");
+        let mut arr = [0u8; 16];
+        for i in 0..16u32 {
+            arr[i as usize] = bytes.get(i).unwrap();
+        }
+        let _ = env;
+        i128::from_be_bytes(arr)
+    }
+
+    fn bump_config_state_internal(env: &Env) {
+        let storage = env.storage().persistent();
+        storage.extend_ttl(&DataKey::Admin, LEDGER_THRESHOLD, LEDGER_BUMP);
+        storage.extend_ttl(&DataKey::PoolContract, LEDGER_THRESHOLD, LEDGER_BUMP);
+        storage.extend_ttl(&DataKey::VotingQuorum, LEDGER_THRESHOLD, LEDGER_BUMP);
+        storage.extend_ttl(&DataKey::ProposalCount, LEDGER_THRESHOLD, LEDGER_BUMP);
+        storage.extend_ttl(&DataKey::ActiveProposals, LEDGER_THRESHOLD, LEDGER_BUMP);
+        storage.extend_ttl(&DataKey::RecentProposals, LEDGER_THRESHOLD, LEDGER_BUMP);
+    }
+
+    fn bump_proposal_state_internal(env: &Env, id: &BytesN<32>) {
+        let storage = env.storage().persistent();
+        let key = DataKey::Proposal(id.clone());
+        if storage.has(&key) {
+            storage.extend_ttl(&key, LEDGER_THRESHOLD, LEDGER_BUMP);
+        }
+    }
+}
+
+fn format_result(env: &Env, label: &str, value: i128) -> Bytes {
+    let mut buf = [0u8; 64];
+    let mut n = 0usize;
+    for b in label.as_bytes() {
+        buf[n] = *b;
+        n += 1;
+    }
+    buf[n] = b'=';
+    n += 1;
+    if value < 0 {
+        buf[n] = b'-';
+        n += 1;
+    }
+    let start = n;
+    let mut v = value.unsigned_abs();
+    if v == 0 {
+        buf[n] = b'0';
+        n += 1;
+    }
+    while v > 0 {
+        buf[n] = (v % 10) as u8 + b'0';
+        n += 1;
+        v /= 10;
+    }
+    let mut lo = start;
+    let mut hi = n - 1;
+    while lo < hi {
+        buf.swap(lo, hi);
+        lo += 1;
+        hi -= 1;
+    }
+    Bytes::from_slice(env, &buf[..n])
+}
+
+#[cfg(test)]
+mod tests;
diff --git a/smartcontract/contracts/governance/src/tests.rs b/smartcontract/contracts/governance/src/tests.rs
new file mode 100644
index 0000000..e2c1b87
--- /dev/null
+++ b/smartcontract/contracts/governance/src/tests.rs
@@ -0,0 +1,528 @@
+extern crate std;
+
+use super::{Governance, GovernanceClient, ProposalStatus, ProposalType};
+use soroban_sdk::{
+    contract, contractimpl, contracttype, symbol_short, testutils::Address as _,
+    testutils::Ledger as _, vec, Address, Bytes, BytesN, Env, Map, String, Symbol, Vec,
+};
+
+const DAY_SECS: u64 = 48 * 60 * 60;
+
+#[contract]
+struct TestPool;
+
+#[contractimpl]
+impl TestPool {
+    pub fn initialize(env: Env, members: Vec<Address>) {
+        env.storage()
+            .persistent()
+            .set(&DataKeyTest::Members, &members);
+    }
+
+    pub fn members(env: Env) -> Vec<Address> {
+        env.storage()
+            .persistent()
+            .get(&DataKeyTest::Members)
+            .unwrap_or(Vec::new(&env))
+    }
+
+    pub fn apply_governance_proposal(
+        env: Env,
+        caller: Address,
+        proposal_type: Symbol,
+        new_value: i128,
+    ) {
+        caller.require_auth();
+        env.storage()
+            .persistent()
+            .set(&DataKeyTest::LastType(proposal_type.clone()), &new_value);
+        env.events()
+            .publish((symbol_short!("gov_ap"), proposal_type), new_value);
+    }
+
+    pub fn last_value(env: Env, proposal_type: Symbol) -> i128 {
+        env.storage()
+            .persistent()
+            .get(&DataKeyTest::LastType(proposal_type))
+            .unwrap_or(0)
+    }
+}
+
+#[contracttype]
+pub enum DataKeyTest {
+    Members,
+    LastType(Symbol),
+}
+
+struct Ctx {
+    env: Env,
+    pool_id: Address,
+    gov_id: Address,
+    admin: Address,
+    proposer: Address,
+    voters: [Address; 2],
+}
+
+fn params_i128(env: &Env, key: &str, value: i128) -> Map<String, Bytes> {
+    let mut m = Map::new(env);
+    m.set(
+        String::from_str(env, key),
+        Bytes::from_array(env, &value.to_be_bytes()),
+    );
+    m
+}
+
+fn empty_params(env: &Env) -> Map<String, Bytes> {
+    Map::new(env)
+}
+
+fn setup() -> Ctx {
+    let env = Env::default();
+    env.mock_all_auths();
+
+    let admin = Address::generate(&env);
+    let proposer = Address::generate(&env);
+    let voter1 = Address::generate(&env);
+    let voter2 = Address::generate(&env);
+
+    let pool_id = env.register_contract(None, TestPool);
+    TestPoolClient::new(&env, &pool_id).initialize(&vec![
+        &env,
+        proposer.clone(),
+        voter1.clone(),
+        voter2.clone(),
+    ]);
+
+    let gov_id = env.register_contract(None, Governance);
+    let gov = GovernanceClient::new(&env, &gov_id);
+    gov.initialize(&admin, &pool_id, &51u32);
+
+    Ctx {
+        env,
+        pool_id,
+        gov_id,
+        admin,
+        proposer,
+        voters: [voter1, voter2],
+    }
+}
+
+/// Creates a proposal proposed by ctx.proposer and passes it by having both
+/// other members vote in favor (2/3 votes meets the 51% quorum).
+fn create_and_pass(
+    ctx: &Ctx,
+    proposal_type: ProposalType,
+    params: Map<String, Bytes>,
+) -> BytesN<32> {
+    let gov = GovernanceClient::new(&ctx.env, &ctx.gov_id);
+    let id = gov.create_proposal(
+        &ctx.proposer,
+        &proposal_type,
+        &String::from_str(&ctx.env, "test proposal"),
+        &params,
+    );
+    gov.vote(&ctx.voters[0], &id, &true);
+    gov.vote(&ctx.voters[1], &id, &true);
+    id
+}
+
+#[test]
+fn initialize_stores_config() {
+    let ctx = setup();
+    let gov = GovernanceClient::new(&ctx.env, &ctx.gov_id);
+    assert_eq!(gov.get_voting_quorum(), 51u32);
+    assert_eq!(gov.admin(), ctx.admin);
+    assert_eq!(gov.pool_contract(), ctx.pool_id);
+    assert_eq!(gov.voting_period_secs(), DAY_SECS);
+}
+
+#[test]
+#[should_panic(expected = "quorum must be 1-100")]
+fn initialize_rejects_zero_quorum() {
+    let env = Env::default();
+    env.mock_all_auths();
+    let pool_id = env.register_contract(None, TestPool);
+    let gov_id = env.register_contract(None, Governance);
+    let gov = GovernanceClient::new(&env, &gov_id);
+    gov.initialize(&Address::generate(&env), &pool_id, &0u32);
+}
+
+#[test]
+#[should_panic(expected = "quorum must be 1-100")]
+fn initialize_rejects_quorum_over_100() {
+    let env = Env::default();
+    env.mock_all_auths();
+    let pool_id = env.register_contract(None, TestPool);
+    let gov_id = env.register_contract(None, Governance);
+    let gov = GovernanceClient::new(&env, &gov_id);
+    gov.initialize(&Address::generate(&env), &pool_id, &101u32);
+}
+
+#[test]
+#[should_panic(expected = "already initialized")]
+fn cannot_initialize_twice() {
+    let ctx = setup();
+    let gov = GovernanceClient::new(&ctx.env, &ctx.gov_id);
+    gov.initialize(&ctx.admin, &ctx.pool_id, &51u32);
+}
+
+#[test]
+#[should_panic(expected = "not a pool member")]
+fn non_member_cannot_create_proposal() {
+    let ctx = setup();
+    let outsider = Address::generate(&ctx.env);
+    let gov = GovernanceClient::new(&ctx.env, &ctx.gov_id);
+    gov.create_proposal(
+        &outsider,
+        &ProposalType::ChangeDepositAmount,
+        &String::from_str(&ctx.env, "hostile proposal"),
+        &params_i128(&ctx.env, "deposit_amount", 1),
+    );
+}
+
+#[test]
+fn create_and_read_proposal() {
+    let ctx = setup();
+    let gov = GovernanceClient::new(&ctx.env, &ctx.gov_id);
+
+    let id = gov.create_proposal(
+        &ctx.proposer,
+        &ProposalType::ChangeDepositAmount,
+        &String::from_str(&ctx.env, "raise deposit"),
+        &params_i128(&ctx.env, "deposit_amount", 250),
+    );
+
+    let p = gov.get_proposal(&id);
+    assert_eq!(p.id, id);
+    assert_eq!(p.proposer, ctx.proposer);
+    assert_eq!(p.proposal_type, ProposalType::ChangeDepositAmount);
+    assert_eq!(p.status, ProposalStatus::Active);
+    assert_eq!(p.created_at, 0u64);
+    assert_eq!(p.expires_at, DAY_SECS);
+    assert_eq!(p.votes_for.len(), 0u32);
+    assert_eq!(p.votes_against.len(), 0u32);
+    assert_eq!(p.execution_result, None);
+
+    let active = gov.get_active_proposals(&ctx.pool_id);
+    assert_eq!(active.len(), 1u32);
+}
+
+#[test]
+#[should_panic(expected = "description required")]
+fn empty_description_rejected() {
+    let ctx = setup();
+    let gov = GovernanceClient::new(&ctx.env, &ctx.gov_id);
+    gov.create_proposal(
+        &ctx.proposer,
+        &ProposalType::Custom,
+        &String::from_str(&ctx.env, ""),
+        &empty_params(&ctx.env),
+    );
+}
+
+#[test]
+#[should_panic(expected = "description too long")]
+fn overlong_description_rejected() {
+    let ctx = setup();
+    let gov = GovernanceClient::new(&ctx.env, &ctx.gov_id);
+    let long = String::from_str(&ctx.env, &"x".repeat(501));
+    gov.create_proposal(
+        &ctx.proposer,
+        &ProposalType::Custom,
+        &long,
+        &empty_params(&ctx.env),
+    );
+}
+
+#[test]
+#[should_panic(expected = "too many active proposals")]
+fn max_three_active_proposals_enforced() {
+    let ctx = setup();
+    let gov = GovernanceClient::new(&ctx.env, &ctx.gov_id);
+    for i in 0..4u32 {
+        gov.create_proposal(
+            &ctx.proposer,
+            &ProposalType::Custom,
+            &String::from_str(&ctx.env, "custom"),
+            &params_i128(&ctx.env, "note", i as i128),
+        );
+    }
+}
+
+#[test]
+fn votes_are_counted() {
+    let ctx = setup();
+    let gov = GovernanceClient::new(&ctx.env, &ctx.gov_id);
+    let id = gov.create_proposal(
+        &ctx.proposer,
+        &ProposalType::ChangeDepositAmount,
+        &String::from_str(&ctx.env, "raise deposit"),
+        &params_i128(&ctx.env, "deposit_amount", 250),
+    );
+
+    gov.vote(&ctx.voters[0], &id, &true);
+    let p = gov.get_proposal(&id);
+    assert_eq!(p.votes_for.len(), 1u32);
+
+    gov.vote(&ctx.voters[1], &id, &false);
+    let p = gov.get_proposal(&id);
+    assert_eq!(p.votes_against.len(), 1u32);
+    // 1 of 3 for (33%) does not meet 51% quorum yet.
+    assert_eq!(p.status, ProposalStatus::Active);
+    assert_eq!(gov.has_voted(&id, &ctx.voters[1]), Some(false));
+}
+
+#[test]
+#[should_panic(expected = "already voted")]
+fn double_vote_rejected() {
+    let ctx = setup();
+    let gov = GovernanceClient::new(&ctx.env, &ctx.gov_id);
+    let id = gov.create_proposal(
+        &ctx.proposer,
+        &ProposalType::ChangeDepositAmount,
+        &String::from_str(&ctx.env, "raise deposit"),
+        &params_i128(&ctx.env, "deposit_amount", 250),
+    );
+    gov.vote(&ctx.voters[0], &id, &true);
+    gov.vote(&ctx.voters[0], &id, &true);
+}
+
+#[test]
+#[should_panic(expected = "proposer cannot vote")]
+fn proposer_cannot_vote_own_proposal() {
+    let ctx = setup();
+    let gov = GovernanceClient::new(&ctx.env, &ctx.gov_id);
+    let id = gov.create_proposal(
+        &ctx.proposer,
+        &ProposalType::ChangeDepositAmount,
+        &String::from_str(&ctx.env, "raise deposit"),
+        &params_i128(&ctx.env, "deposit_amount", 250),
+    );
+    gov.vote(&ctx.proposer, &id, &true);
+}
+
+#[test]
+#[should_panic(expected = "not a pool member")]
+fn non_member_cannot_vote() {
+    let ctx = setup();
+    let gov = GovernanceClient::new(&ctx.env, &ctx.gov_id);
+    let id = gov.create_proposal(
+        &ctx.proposer,
+        &ProposalType::ChangeDepositAmount,
+        &String::from_str(&ctx.env, "raise deposit"),
+        &params_i128(&ctx.env, "deposit_amount", 250),
+    );
+    let outsider = Address::generate(&ctx.env);
+    gov.vote(&outsider, &id, &true);
+}
+
+#[test]
+#[should_panic(expected = "quorum not met")]
+fn execute_before_quorum_fails() {
+    let ctx = setup();
+    let gov = GovernanceClient::new(&ctx.env, &ctx.gov_id);
+    let id = gov.create_proposal(
+        &ctx.proposer,
+        &ProposalType::ChangeDepositAmount,
+        &String::from_str(&ctx.env, "raise deposit"),
+        &params_i128(&ctx.env, "deposit_amount", 250),
+    );
+    gov.vote(&ctx.voters[0], &id, &true);
+    gov.execute_proposal(&ctx.voters[0], &id);
+}
+
+#[test]
+fn execute_applies_change_to_pool_via_cpi() {
+    let ctx = setup();
+    let gov = GovernanceClient::new(&ctx.env, &ctx.gov_id);
+
+    let id = create_and_pass(
+        &ctx,
+        ProposalType::ChangeDepositAmount,
+        params_i128(&ctx.env, "deposit_amount", 500),
+    );
+
+    let p = gov.get_proposal(&id);
+    assert_eq!(p.status, ProposalStatus::Passed);
+
+    gov.execute_proposal(&ctx.voters[0], &id);
+
+    let p = gov.get_proposal(&id);
+    assert_eq!(p.status, ProposalStatus::Executed);
+    assert!(p.execution_result.is_some());
+    assert_eq!(
+        TestPoolClient::new(&ctx.env, &ctx.pool_id)
+            .last_value(&Symbol::new(&ctx.env, "change_deposit_amount")),
+        500i128
+    );
+
+    // Executed proposals leave the active list.
+    assert_eq!(gov.get_active_proposals(&ctx.pool_id).len(), 0u32);
+    assert_eq!(gov.get_recent_proposals().len(), 1u32);
+}
+
+#[test]
+#[should_panic(expected = "proposal expired")]
+fn expired_proposal_cannot_be_voted_on() {
+    let ctx = setup();
+    let gov = GovernanceClient::new(&ctx.env, &ctx.gov_id);
+    let id = gov.create_proposal(
+        &ctx.proposer,
+        &ProposalType::ChangeDepositAmount,
+        &String::from_str(&ctx.env, "raise deposit"),
+        &params_i128(&ctx.env, "deposit_amount", 250),
+    );
+
+    ctx.env.ledger().set_timestamp(DAY_SECS + 1);
+    gov.vote(&ctx.voters[0], &id, &true);
+}
+
+#[test]
+#[should_panic(expected = "proposal expired")]
+fn passed_but_expired_proposal_cannot_execute() {
+    let ctx = setup();
+    let gov = GovernanceClient::new(&ctx.env, &ctx.gov_id);
+    let id = create_and_pass(
+        &ctx,
+        ProposalType::ChangeDepositAmount,
+        params_i128(&ctx.env, "deposit_amount", 500),
+    );
+
+    ctx.env.ledger().set_timestamp(DAY_SECS + 1);
+    gov.execute_proposal(&ctx.voters[0], &id);
+}
+
+#[test]
+fn expire_proposal_marks_expired() {
+    let ctx = setup();
+    let gov = GovernanceClient::new(&ctx.env, &ctx.gov_id);
+    let id = gov.create_proposal(
+        &ctx.proposer,
+        &ProposalType::ChangeDepositAmount,
+        &String::from_str(&ctx.env, "raise deposit"),
+        &params_i128(&ctx.env, "deposit_amount", 250),
+    );
+
+    ctx.env.ledger().set_timestamp(DAY_SECS + 1);
+    gov.expire_proposal(&ctx.voters[0], &id);
+    assert_eq!(gov.get_proposal(&id).status, ProposalStatus::Expired);
+}
+
+#[test]
+#[should_panic(expected = "voting period not over")]
+fn expire_before_deadline_fails() {
+    let ctx = setup();
+    let gov = GovernanceClient::new(&ctx.env, &ctx.gov_id);
+    let id = gov.create_proposal(
+        &ctx.proposer,
+        &ProposalType::ChangeDepositAmount,
+        &String::from_str(&ctx.env, "raise deposit"),
+        &params_i128(&ctx.env, "deposit_amount", 250),
+    );
+    gov.expire_proposal(&ctx.voters[0], &id);
+}
+
+#[test]
+fn against_quorum_rejects_proposal() {
+    let ctx = setup();
+    let gov = GovernanceClient::new(&ctx.env, &ctx.gov_id);
+    let id = gov.create_proposal(
+        &ctx.proposer,
+        &ProposalType::AddPenalty,
+        &String::from_str(&ctx.env, "harsh penalty"),
+        &params_i128(&ctx.env, "percentage", 90),
+    );
+
+    gov.vote(&ctx.voters[0], &id, &false);
+    gov.vote(&ctx.voters[1], &id, &false);
+
+    assert_eq!(gov.get_proposal(&id).status, ProposalStatus::Rejected);
+    assert_eq!(gov.get_active_proposals(&ctx.pool_id).len(), 0u32);
+}
+
+#[test]
+#[should_panic(expected = "quorum not met")]
+fn rejected_proposal_cannot_execute() {
+    let ctx = setup();
+    let gov = GovernanceClient::new(&ctx.env, &ctx.gov_id);
+    let id = gov.create_proposal(
+        &ctx.proposer,
+        &ProposalType::AddPenalty,
+        &String::from_str(&ctx.env, "harsh penalty"),
+        &params_i128(&ctx.env, "percentage", 90),
+    );
+    gov.vote(&ctx.voters[0], &id, &false);
+    gov.vote(&ctx.voters[1], &id, &false);
+    gov.execute_proposal(&ctx.voters[0], &id);
+}
+
+#[test]
+fn change_quorum_updates_governance_config() {
+    let ctx = setup();
+    let gov = GovernanceClient::new(&ctx.env, &ctx.gov_id);
+    let id = create_and_pass(
+        &ctx,
+        ProposalType::ChangeQuorum,
+        params_i128(&ctx.env, "quorum", 66),
+    );
+    gov.execute_proposal(&ctx.voters[0], &id);
+    assert_eq!(gov.get_voting_quorum(), 66u32);
+}
+
+#[test]
+fn extend_deadline_and_penalty_proposals_apply() {
+    let ctx = setup();
+    let gov = GovernanceClient::new(&ctx.env, &ctx.gov_id);
+
+    let id1 = create_and_pass(
+        &ctx,
+        ProposalType::ExtendDeadline,
+        params_i128(&ctx.env, "seconds", 3600),
+    );
+    gov.execute_proposal(&ctx.voters[0], &id1);
+
+    let id2 = create_and_pass(
+        &ctx,
+        ProposalType::AddPenalty,
+        params_i128(&ctx.env, "percentage", 5),
+    );
+    gov.execute_proposal(&ctx.voters[0], &id2);
+
+    let id3 = create_and_pass(&ctx, ProposalType::RemovePenalty, empty_params(&ctx.env));
+    gov.execute_proposal(&ctx.voters[0], &id3);
+
+    let pool = TestPoolClient::new(&ctx.env, &ctx.pool_id);
+    assert_eq!(
+        pool.last_value(&Symbol::new(&ctx.env, "extend_deadline")),
+        3600i128
+    );
+    assert_eq!(
+        pool.last_value(&Symbol::new(&ctx.env, "add_penalty")),
+        5i128
+    );
+    assert_eq!(
+        pool.last_value(&Symbol::new(&ctx.env, "remove_penalty")),
+        0i128
+    );
+}
+
+#[test]
+#[should_panic(expected = "missing parameter")]
+fn missing_parameter_traps_on_execute() {
+    let ctx = setup();
+    let gov = GovernanceClient::new(&ctx.env, &ctx.gov_id);
+    let id = create_and_pass(
+        &ctx,
+        ProposalType::ChangeDepositAmount,
+        params_i128(&ctx.env, "wrong_key", 5),
+    );
+    gov.execute_proposal(&ctx.voters[0], &id);
+}
+
+#[test]
+#[should_panic(expected = "wrong pool")]
+fn active_proposals_query_rejects_wrong_pool() {
+    let ctx = setup();
+    let gov = GovernanceClient::new(&ctx.env, &ctx.gov_id);
+    gov.get_active_proposals(&Address::generate(&ctx.env));
+}
diff --git a/smartcontract/contracts/rotational/src/lib.rs b/smartcontract/contracts/rotational/src/lib.rs
index e456032..39b02c3 100644
--- a/smartcontract/contracts/rotational/src/lib.rs
+++ b/smartcontract/contracts/rotational/src/lib.rs
@@ -38,6 +38,10 @@ pub enum DataKey {
     SupportedTokens,
     IsCustom,
     CustomDeadlines,
+    /// Optional address of the attached DAO governance contract.
+    GovernanceContract,
+    /// Late/missed-deposit penalty percentage governable by the DAO (0-100).
+    PenaltyPercentage,
 }
 
 // ── Contract ──────────────────────────────────────────────────────────────────
@@ -241,7 +245,6 @@ impl RotationalPool {
         Self::bump_config_state_internal(&env);
     }
 
-
     pub fn add_member(env: Env, admin: Address, new_member: Address) {
         admin.require_auth();
 
@@ -462,6 +465,71 @@ impl RotationalPool {
         Self::bump_config_state_internal(&env);
     }
 
+    // ── DAO governance ────────────────────────────────────────────────────
+
+    /// Register the DAO governance contract allowed to apply proposals.
+    pub fn set_governance_contract(env: Env, admin: Address, governance: Address) {
+        admin.require_auth();
+        let storage = env.storage().persistent();
+        let stored_admin: Address = storage.get(&DataKey::Admin).unwrap();
+        assert!(admin == stored_admin, "not admin");
+
+        storage.set(&DataKey::GovernanceContract, &governance);
+        Self::bump_config_state_internal(&env);
+
+        env.events()
+            .publish((symbol_short!("gov_set"), admin), governance);
+    }
+
+    /// Apply a governance-approved parameter change. Callable by the pool
+    /// admin directly or by the registered governance contract via CPI.
+    ///
+    /// Proposal types (symbols):
+    ///   - "change_deposit_amount" -> fixed per-round deposit in stroops (> 0)
+    ///   - "extend_deadline"       -> new round duration in seconds (> 0)
+    ///   - "add_penalty"           -> penalty percentage 0-100
+    ///   - "remove_penalty"        -> clears penalty percentage
+    pub fn apply_governance_proposal(
+        env: Env,
+        caller: Address,
+        proposal_type: Symbol,
+        new_value: i128,
+    ) {
+        caller.require_auth();
+        let storage = env.storage().persistent();
+        let stored_admin: Address = storage.get(&DataKey::Admin).unwrap();
+        let gov: Option<Address> = storage.get(&DataKey::GovernanceContract);
+        assert!(
+            caller == stored_admin || gov.map_or(false, |g| g == caller),
+            "not authorized"
+        );
+
+        let change_deposit = Symbol::new(&env, "change_deposit_amount");
+        let extend_deadline = Symbol::new(&env, "extend_deadline");
+        let add_penalty = Symbol::new(&env, "add_penalty");
+        let remove_penalty = Symbol::new(&env, "remove_penalty");
+
+        if proposal_type == change_deposit {
+            assert!(new_value > 0, "deposit must be > 0");
+            storage.set(&DataKey::DepositAmount, &new_value);
+        } else if proposal_type == extend_deadline {
+            assert!(new_value > 0, "round duration must be > 0");
+            storage.set(&DataKey::RoundDuration, &(new_value as u64));
+        } else if proposal_type == add_penalty {
+            assert!(new_value >= 0 && new_value <= 100, "penalty must be 0-100");
+            storage.set(&DataKey::PenaltyPercentage, &(new_value as u32));
+        } else if proposal_type == remove_penalty {
+            storage.set(&DataKey::PenaltyPercentage, &0u32);
+        } else {
+            panic!("unsupported proposal type");
+        }
+
+        Self::bump_config_state_internal(&env);
+
+        env.events()
+            .publish((symbol_short!("gov_appl"), proposal_type), new_value);
+    }
+
     pub fn bump_state(env: Env) {
         Self::bump_config_state_internal(&env);
         let storage = env.storage().persistent();
@@ -503,6 +571,12 @@ impl RotationalPool {
         if storage.has(&DataKey::CustomDeadlines) {
             storage.extend_ttl(&DataKey::CustomDeadlines, LEDGER_THRESHOLD, LEDGER_BUMP);
         }
+        if storage.has(&DataKey::GovernanceContract) {
+            storage.extend_ttl(&DataKey::GovernanceContract, LEDGER_THRESHOLD, LEDGER_BUMP);
+        }
+        if storage.has(&DataKey::PenaltyPercentage) {
+            storage.extend_ttl(&DataKey::PenaltyPercentage, LEDGER_THRESHOLD, LEDGER_BUMP);
+        }
     }
 
     /// Allows admin to change the round duration for future rounds.
@@ -654,6 +728,35 @@ impl RotationalPool {
             .unwrap_or(Vec::new(&env))
     }
 
+    /// Fixed deposit amount per round in stroops.
+    pub fn deposit_amount(env: Env) -> i128 {
+        env.storage()
+            .persistent()
+            .get(&DataKey::DepositAmount)
+            .unwrap_or(0)
+    }
+
+    /// Round duration in seconds.
+    pub fn round_duration(env: Env) -> u64 {
+        env.storage()
+            .persistent()
+            .get(&DataKey::RoundDuration)
+            .unwrap_or(0)
+    }
+
+    /// Address of the attached DAO governance contract, if any.
+    pub fn governance_contract(env: Env) -> Option<Address> {
+        env.storage().persistent().get(&DataKey::GovernanceContract)
+    }
+
+    /// Penalty percentage applied to missed rounds (0 by default).
+    pub fn penalty_percentage(env: Env) -> u32 {
+        env.storage()
+            .persistent()
+            .get(&DataKey::PenaltyPercentage)
+            .unwrap_or(0)
+    }
+
     // ── Helpers ────────────────────────────────────────────────────────────
 
     fn is_member(members: &Vec<Address>, who: &Address) -> bool {
diff --git a/smartcontract/contracts/rotational/src/tests.rs b/smartcontract/contracts/rotational/src/tests.rs
index f6d8096..0284eb4 100644
--- a/smartcontract/contracts/rotational/src/tests.rs
+++ b/smartcontract/contracts/rotational/src/tests.rs
@@ -3,7 +3,7 @@
 use super::{RotationalPool, RotationalPoolClient};
 use soroban_sdk::{
     testutils::{Address as _, Ledger as _},
-    token, Address, Env, Vec,
+    token, Address, Env, Symbol, Vec,
 };
 
 #[test]
diff --git a/smartcontract/contracts/target/src/lib.rs b/smartcontract/contracts/target/src/lib.rs
index 54824cd..d8694b0 100644
--- a/smartcontract/contracts/target/src/lib.rs
+++ b/smartcontract/contracts/target/src/lib.rs
@@ -24,6 +24,10 @@ pub enum DataKey {
     ReputationTracker,
     /// Optional allowlist of accepted token addresses (empty = unrestricted).
     SupportedTokens,
+    /// Optional address of the attached DAO governance contract.
+    GovernanceContract,
+    /// Late/missed-deposit penalty percentage governable by the DAO (0-100).
+    PenaltyPercentage,
 }
 
 const LEDGER_THRESHOLD: u32 = 518400;
@@ -429,6 +433,12 @@ impl TargetPool {
         if storage.has(&DataKey::SupportedTokens) {
             storage.extend_ttl(&DataKey::SupportedTokens, LEDGER_THRESHOLD, LEDGER_BUMP);
         }
+        if storage.has(&DataKey::GovernanceContract) {
+            storage.extend_ttl(&DataKey::GovernanceContract, LEDGER_THRESHOLD, LEDGER_BUMP);
+        }
+        if storage.has(&DataKey::PenaltyPercentage) {
+            storage.extend_ttl(&DataKey::PenaltyPercentage, LEDGER_THRESHOLD, LEDGER_BUMP);
+        }
     }
 
     /// Point this pool at a deployed ReputationTracker contract so deposits
@@ -443,6 +453,70 @@ impl TargetPool {
         Self::bump_config_state_internal(&env);
     }
 
+    // ── DAO governance ────────────────────────────────────────────────────
+
+    /// Register the DAO governance contract allowed to apply proposals.
+    pub fn set_governance_contract(env: Env, admin: Address, governance: Address) {
+        admin.require_auth();
+        let storage = env.storage().persistent();
+        let stored_admin: Address = storage.get(&DataKey::Admin).unwrap();
+        assert!(admin == stored_admin, "not admin");
+
+        storage.set(&DataKey::GovernanceContract, &governance);
+        Self::bump_config_state_internal(&env);
+
+        env.events()
+            .publish((symbol_short!("gov_set"), admin), governance);
+    }
+
+    /// Apply a governance-approved parameter change. Callable by the pool
+    /// admin directly or by the registered governance contract via CPI.
+    ///
+    /// Proposal types (symbols):
+    ///   - "extend_deadline" -> ledgers to add to the deadline (> 0)
+    ///   - "add_penalty"     -> penalty percentage 0-100
+    ///   - "remove_penalty"  -> clears penalty percentage
+    pub fn apply_governance_proposal(
+        env: Env,
+        caller: Address,
+        proposal_type: Symbol,
+        new_value: i128,
+    ) {
+        caller.require_auth();
+        let storage = env.storage().persistent();
+        let stored_admin: Address = storage.get(&DataKey::Admin).unwrap();
+        let gov: Option<Address> = storage.get(&DataKey::GovernanceContract);
+        assert!(
+            caller == stored_admin || gov.map_or(false, |g| g == caller),
+            "not authorized"
+        );
+
+        let extend_deadline = Symbol::new(&env, "extend_deadline");
+        let add_penalty = Symbol::new(&env, "add_penalty");
+        let remove_penalty = Symbol::new(&env, "remove_penalty");
+
+        if proposal_type == extend_deadline {
+            assert!(new_value > 0, "extension must be > 0");
+            assert!(new_value <= u32::MAX as i128, "extension too large");
+            let deadline: u32 = storage.get(&DataKey::Deadline).unwrap();
+            let extended = deadline.checked_add(new_value as u32);
+            assert!(extended.is_some(), "deadline overflow");
+            storage.set(&DataKey::Deadline, &extended.unwrap());
+        } else if proposal_type == add_penalty {
+            assert!(new_value >= 0 && new_value <= 100, "penalty must be 0-100");
+            storage.set(&DataKey::PenaltyPercentage, &(new_value as u32));
+        } else if proposal_type == remove_penalty {
+            storage.set(&DataKey::PenaltyPercentage, &0u32);
+        } else {
+            panic!("unsupported proposal type");
+        }
+
+        Self::bump_config_state_internal(&env);
+
+        env.events()
+            .publish((symbol_short!("gov_appl"), proposal_type), new_value);
+    }
+
     // ── Views ──────────────────────────────────────────────────────────────
 
     pub fn get_version(_env: Env) -> u32 {
@@ -526,6 +600,19 @@ impl TargetPool {
             .unwrap_or(Vec::new(&env))
     }
 
+    /// Address of the attached DAO governance contract, if any.
+    pub fn governance_contract(env: Env) -> Option<Address> {
+        env.storage().persistent().get(&DataKey::GovernanceContract)
+    }
+
+    /// Penalty percentage applied to missed deposits (0 by default).
+    pub fn penalty_percentage(env: Env) -> u32 {
+        env.storage()
+            .persistent()
+            .get(&DataKey::PenaltyPercentage)
+            .unwrap_or(0)
+    }
+
     // ── Helpers ────────────────────────────────────────────────────────────
 
     fn is_member(members: &Vec<Address>, who: &Address) -> bool {
diff --git a/smartcontract/contracts/target/src/tests.rs b/smartcontract/contracts/target/src/tests.rs
index 540ed37..8d7fb57 100644
--- a/smartcontract/contracts/target/src/tests.rs
+++ b/smartcontract/contracts/target/src/tests.rs
@@ -3,7 +3,7 @@
 use super::{TargetPool, TargetPoolClient};
 use soroban_sdk::{
     testutils::{Address as _, Ledger as _},
-    token, Address, Env, Vec,
+    token, Address, Env, Symbol, Vec,
 };
 
 #[test]
@@ -909,3 +909,42 @@ fn test_deposit_succeeds_when_pool_token_is_in_allowlist() {
     client.deposit(&member_a, &10i128);
     assert_eq!(client.total_deposited(), 10);
 }
+
+// ── DAO governance integration ───────────────────────────────────────────────
+
+#[test]
+fn governance_contract_can_extend_deadline() {
+    let env = Env::default();
+    env.mock_all_auths();
+    let (client, _token, admin, _a, _b) = setup_target_pool(&env);
+
+    let gov = Address::generate(&env);
+    client.set_governance_contract(&admin, &gov);
+    assert_eq!(client.governance_contract(), Some(gov.clone()));
+
+    client.apply_governance_proposal(&gov, &Symbol::new(&env, "extend_deadline"), &500i128);
+}
+
+#[test]
+fn admin_can_apply_penalty_proposals_directly() {
+    let env = Env::default();
+    env.mock_all_auths();
+    let (client, _token, admin, _a, _b) = setup_target_pool(&env);
+
+    client.apply_governance_proposal(&admin, &Symbol::new(&env, "add_penalty"), &15i128);
+    assert_eq!(client.penalty_percentage(), 15u32);
+
+    client.apply_governance_proposal(&admin, &Symbol::new(&env, "remove_penalty"), &0i128);
+    assert_eq!(client.penalty_percentage(), 0u32);
+}
+
+#[test]
+#[should_panic(expected = "not authorized")]
+fn unauthorized_caller_cannot_apply_proposal() {
+    let env = Env::default();
+    env.mock_all_auths();
+    let (client, _token, _admin, _a, _b) = setup_target_pool(&env);
+
+    let impostor = Address::generate(&env);
+    client.apply_governance_proposal(&impostor, &Symbol::new(&env, "add_penalty"), &10i128);
+}
diff --git a/supabase/migrations/20260824000000_governance_votes.sql b/supabase/migrations/20260824000000_governance_votes.sql
new file mode 100644
index 0000000..3d8f544
--- /dev/null
+++ b/supabase/migrations/20260824000000_governance_votes.sql
@@ -0,0 +1,46 @@
+-- Migration: DAO governance vote mirror (issue #207)
+--
+-- Governance proposals live fully on-chain (contracts/governance). This table
+-- is an off-chain mirror of votes used for realtime UI updates: when a member
+-- casts a vote on-chain the client upserts a row here and Supabase Realtime
+-- broadcasts it to everyone viewing the pool, so counts update without
+-- re-querying Soroban RPC.
+
+ALTER TABLE public.pools
+  ADD COLUMN IF NOT EXISTS governance_contract_id text;
+
+CREATE TABLE IF NOT EXISTS public.governance_votes (
+  id            uuid        PRIMARY KEY DEFAULT gen_random_uuid(),
+  proposal_id   text        NOT NULL,
+  pool_id       uuid        NOT NULL REFERENCES public.pools(id) ON DELETE CASCADE,
+  voter_address text        NOT NULL,
+  vote          boolean     NOT NULL,
+  created_at    timestamptz NOT NULL DEFAULT now(),
+
+  -- One vote per wallet per proposal (enforced on-chain too).
+  CONSTRAINT governance_votes_unique_vote UNIQUE (proposal_id, voter_address),
+  -- Addresses are stored lowercase, mirroring every other table.
+  CONSTRAINT governance_votes_voter_lowercase CHECK (voter_address = lower(voter_address))
+);
+
+CREATE INDEX IF NOT EXISTS idx_governance_votes_pool_id
+  ON public.governance_votes (pool_id);
+
+CREATE INDEX IF NOT EXISTS idx_governance_votes_proposal
+  ON public.governance_votes (proposal_id);
+
+-- ── Row-Level Security ────────────────────────────────────────────────────────
+ALTER TABLE public.governance_votes ENABLE ROW LEVEL SECURITY;
+
+-- Public read — the mirror only exposes aggregate vote data that is already
+-- public on-chain; per-pool visibility is enforced in /api/governance.
+CREATE POLICY "governance_votes_select_public"
+  ON public.governance_votes
+  FOR SELECT
+  USING (true);
+
+-- All writes go through /api/governance with the service-role key.
+-- No INSERT/UPDATE/DELETE policy = direct anon writes stay denied.
+
+-- ── Realtime publication ──────────────────────────────────────────────────────
+ALTER PUBLICATION supabase_realtime ADD TABLE public.governance_votes;