diff --git a/examples/storybook/src/fixtures/governanceRuntimeMock.ts b/examples/storybook/src/fixtures/governanceRuntimeMock.ts
new file mode 100644
index 00000000..656703e8
--- /dev/null
+++ b/examples/storybook/src/fixtures/governanceRuntimeMock.ts
@@ -0,0 +1,172 @@
+import {
+  decodeFunctionData,
+  encodeFunctionResult,
+  parseAbi,
+  type Address,
+  type Hex,
+} from 'viem'
+
+const HOUSES_READ_ABI = parseAbi([
+  'function minimumStake(uint8 house) view returns (uint256)',
+  'function getMember(address account) view returns ((uint8 house, uint8 status, uint256 stakedAmount, uint64 joinedAt, uint64 updatedAt, uint64 unstakedAt, uint256 memberIndex, string name, string socialLinks, string projectWebpage, string missionStatement, string distributionStrategy))',
+  'function getActiveMembers(uint8 house) view returns (address[])',
+  'function cycleStartTime() view returns (uint64)',
+  'function termDuration() view returns (uint64)',
+  'function votingTermLength() view returns (uint64)',
+  'function isVotingPeriod() view returns (bool)',
+  'function getCurrentVoteId() view returns (uint256)',
+  'function getVoteConfig(uint256 voteId) view returns ((uint64 startTime, uint64 endTime, uint64 executedAt, bool executed))',
+  'function getVoteRecipients(uint256 voteId) view returns (address[])',
+  'function getHasVoted(uint256 voteId, address voter) view returns (bool)',
+  'function getFinalizedUnits(uint256 voteId, address recipient) view returns (uint128)',
+  'function flowSplitterConfig() view returns (address splitter, uint256 poolId, address poolAddress)',
+])
+
+const GOOD_ID_READ_ABI = parseAbi([
+  'function getWhitelistedRoot(address account) view returns (address)',
+])
+
+export const MOCK_HOUSES = '0x4444444444444444444444444444444444444444' as Address
+export const MOCK_GOOD_ID = '0x5555555555555555555555555555555555555555' as Address
+export const MOCK_CITIZEN = '0x6666666666666666666666666666666666666666' as Address
+export const MOCK_ALIGNMENT = '0x7777777777777777777777777777777777777777' as Address
+export const MOCK_POOL = '0x8888888888888888888888888888888888888888' as Address
+
+export interface MockGovernanceReadOptions {
+  memberStatus?: 0 | 1 | 2 | 3 | 4
+  memberStatusByAccount?: Record<string, 0 | 1 | 2 | 3 | 4>
+  memberHouseByAccount?: Record<string, 0 | 1>
+}
+
+export function encodeMockGovernanceRead(
+  to: Address,
+  data: Hex,
+  options: MockGovernanceReadOptions = {},
+): Hex {
+  if (to.toLowerCase() === MOCK_GOOD_ID.toLowerCase()) {
+    const decoded = decodeFunctionData({ abi: GOOD_ID_READ_ABI, data })
+    if (decoded.functionName !== 'getWhitelistedRoot') {
+      throw new Error(`Unexpected GoodID read: ${decoded.functionName}`)
+    }
+    return encodeFunctionResult({
+      abi: GOOD_ID_READ_ABI,
+      functionName: 'getWhitelistedRoot',
+      result: MOCK_CITIZEN,
+    })
+  }
+
+  if (to.toLowerCase() !== MOCK_HOUSES.toLowerCase()) {
+    throw new Error(`Unexpected contract address: ${to}`)
+  }
+
+  const decoded = decodeFunctionData({ abi: HOUSES_READ_ABI, data })
+  switch (decoded.functionName) {
+    case 'getMember': {
+      const memberAccount = String(decoded.args[0]).toLowerCase()
+      const memberStatus =
+        options.memberStatusByAccount?.[memberAccount] ??
+        options.memberStatus ??
+        2
+      const hasMembership = memberStatus !== 0 && memberStatus !== 4
+      return encodeFunctionResult({
+        abi: HOUSES_READ_ABI,
+        functionName: 'getMember',
+        result: {
+          house: options.memberHouseByAccount?.[memberAccount] ?? 0,
+          status: memberStatus,
+          stakedAmount: hasMembership ? 1_000n * 10n ** 18n : 0n,
+          joinedAt: hasMembership ? 1_761_955_200n : 0n,
+          updatedAt: hasMembership ? 1_764_547_200n : 0n,
+          unstakedAt: memberStatus === 4 ? 1_784_044_800n : 0n,
+          memberIndex: 0n,
+          name: hasMembership ? 'Mocked Citizen' : '',
+          socialLinks: hasMembership ? 'https://example.com/citizen' : '',
+          projectWebpage: '',
+          missionStatement: '',
+          distributionStrategy: '',
+        },
+      })
+    }
+    case 'minimumStake':
+      return encodeFunctionResult({
+        abi: HOUSES_READ_ABI,
+        functionName: 'minimumStake',
+        result: 1_000n * 10n ** 18n,
+      })
+    case 'getActiveMembers': {
+      const house = Number(decoded.args[0])
+      return encodeFunctionResult({
+        abi: HOUSES_READ_ABI,
+        functionName: 'getActiveMembers',
+        result: house === 0 ? [MOCK_CITIZEN] : [MOCK_ALIGNMENT],
+      })
+    }
+    case 'cycleStartTime':
+      return encodeFunctionResult({
+        abi: HOUSES_READ_ABI,
+        functionName: 'cycleStartTime',
+        result: 1_764_547_200n,
+      })
+    case 'termDuration':
+      return encodeFunctionResult({
+        abi: HOUSES_READ_ABI,
+        functionName: 'termDuration',
+        result: 19_440_000n,
+      })
+    case 'votingTermLength':
+      return encodeFunctionResult({
+        abi: HOUSES_READ_ABI,
+        functionName: 'votingTermLength',
+        result: 1_209_600n,
+      })
+    case 'isVotingPeriod':
+      return encodeFunctionResult({
+        abi: HOUSES_READ_ABI,
+        functionName: 'isVotingPeriod',
+        result: true,
+      })
+    case 'getCurrentVoteId':
+      return encodeFunctionResult({
+        abi: HOUSES_READ_ABI,
+        functionName: 'getCurrentVoteId',
+        result: 1n,
+      })
+    case 'getVoteConfig':
+      return encodeFunctionResult({
+        abi: HOUSES_READ_ABI,
+        functionName: 'getVoteConfig',
+        result: {
+          startTime: 1_783_987_200n,
+          endTime: 1_785_196_800n,
+          executedAt: 0n,
+          executed: false,
+        },
+      })
+    case 'getVoteRecipients':
+      return encodeFunctionResult({
+        abi: HOUSES_READ_ABI,
+        functionName: 'getVoteRecipients',
+        result: [MOCK_ALIGNMENT],
+      })
+    case 'getHasVoted':
+      return encodeFunctionResult({
+        abi: HOUSES_READ_ABI,
+        functionName: 'getHasVoted',
+        result: false,
+      })
+    case 'getFinalizedUnits':
+      return encodeFunctionResult({
+        abi: HOUSES_READ_ABI,
+        functionName: 'getFinalizedUnits',
+        result: 0n,
+      })
+    case 'flowSplitterConfig':
+      return encodeFunctionResult({
+        abi: HOUSES_READ_ABI,
+        functionName: 'flowSplitterConfig',
+        result: [MOCK_HOUSES, 1n, MOCK_POOL],
+      })
+    default:
+      throw new Error(`Unexpected houses read: ${decoded.functionName}`)
+  }
+}
diff --git a/examples/storybook/src/stories/governance-widget/GovernanceOnboarding.stories.tsx b/examples/storybook/src/stories/governance-widget/GovernanceOnboarding.stories.tsx
index eb236198..a73695ff 100644
--- a/examples/storybook/src/stories/governance-widget/GovernanceOnboarding.stories.tsx
+++ b/examples/storybook/src/stories/governance-widget/GovernanceOnboarding.stories.tsx
@@ -62,16 +62,18 @@ function GovernanceStoryFrame({
   walletLabel: string
   children: ReactNode
   dataTestId: string
-  width?: any
+  width?: number
 }) {
   return (
     <GovernanceWidgetProvider data-testId={dataTestId}>
-      <Card outlined>
-        <Text variant="caption" tone="secondary">
-          {walletLabel}
-        </Text>
-      </Card>
-      {children}
+      <YStack width={width} maxWidth="100%" gap="$3">
+        <Card outlined>
+          <Text variant="caption" tone="secondary">
+            {walletLabel}
+          </Text>
+        </Card>
+        {children}
+      </YStack>
     </GovernanceWidgetProvider>
   )
 }
@@ -197,6 +199,7 @@ function CustodialInteractiveFlowStory() {
       storyProps={{
         identityStatus: 'verified',
         initialStepId: 'welcome',
+        initialHouse: 'citizenship',
         walletAddress: '0x4E5B2D7a45C2e31a8F0d09b4bE1fA11aD3aC9F08',
         dataTestId: 'GovernanceOnboardingWidget-interactive-flow',
         transactionSteps: stepsState,
diff --git a/examples/storybook/src/stories/governance-widget/GovernanceRuntime.stories.tsx b/examples/storybook/src/stories/governance-widget/GovernanceRuntime.stories.tsx
index 56f77ac6..ff1d89fb 100644
--- a/examples/storybook/src/stories/governance-widget/GovernanceRuntime.stories.tsx
+++ b/examples/storybook/src/stories/governance-widget/GovernanceRuntime.stories.tsx
@@ -26,8 +26,15 @@ export default meta
 type Story = StoryObj<typeof meta>
 
 const connectedAddress = '0x4E5B2D7a45C2e31a8F0d09b4bE1fA11aD3aC9F08' as const
+const alignmentRecipients = [
+  '0x1111111111111111111111111111111111111111',
+  '0x2222222222222222222222222222222222222222',
+  '0x3333333333333333333333333333333333333333',
+] as const
 
-function createDashboard(overrides: Partial<GovernanceWidgetAdapterState['dashboard']> = {}) {
+function createDashboard(
+  overrides: Partial<GovernanceWidgetAdapterState['dashboard']> = {},
+): GovernanceWidgetAdapterState['dashboard'] {
   return {
     impact: {
       title: 'Distributed',
@@ -55,12 +62,16 @@ function createDashboard(overrides: Partial<GovernanceWidgetAdapterState['dashbo
       title: 'Q3 House Of Alignment Funding Allocation',
       summaryLabel: 'Current top 3 voted',
       options: [
-        { id: 'food-chain', label: 'Local Food Chain', percentage: 42 },
-        { id: 'web3-literacy', label: 'Web3 Literacy', percentage: 31 },
-        { id: 'civic-onboarding', label: 'Civic Onboarding', percentage: 27 },
+        { id: alignmentRecipients[0], label: 'Local Food Chain', percentage: 42 },
+        { id: alignmentRecipients[1], label: 'Web3 Literacy', percentage: 31 },
+        { id: alignmentRecipients[2], label: 'Civic Onboarding', percentage: 27 },
       ],
-      recipients: [],
-      allocationsBps: { 'food-chain': 4200, 'web3-literacy': 3100, 'civic-onboarding': 2700 },
+      recipients: [...alignmentRecipients],
+      allocationsBps: {
+        [alignmentRecipients[0]]: 4200,
+        [alignmentRecipients[1]]: 3100,
+        [alignmentRecipients[2]]: 2700,
+      },
       allocationTotalBps: 10000,
       canVote: false,
       hasVoted: false,
@@ -91,15 +102,15 @@ function createState(
   overrides: Partial<GovernanceWidgetAdapterState> = {},
 ): GovernanceWidgetAdapterState {
   const isConnected = status !== 'disconnected'
-  const member =
-    status === 'active_citizenship' || status === 'active_alignment' || status === 'restake_required'
+  const member: GovernanceWidgetAdapterState['member'] =
+    status === 'active_citizenship' || status === 'active_alignment' || status === 'revoked'
       ? {
           house: status === 'active_alignment' ? 'alignment' : 'citizenship',
-          status: status === 'restake_required' ? 'unstaked' : 'active',
+          status: status === 'revoked' ? 'revoked' : 'active',
           stakedAmount: 250000000000000000000n,
           joinedAt: Date.UTC(2026, 0, 10),
           updatedAt: Date.UTC(2026, 2, 1),
-          unstakedAt: status === 'restake_required' ? Date.UTC(2026, 5, 1) : null,
+          unstakedAt: null,
           memberIndex: 0n,
           name: status === 'active_alignment' ? 'Solar Commons' : 'Maya Citizen',
           socialLinks: 'https://twitter.com/gooddollar',
@@ -118,7 +129,6 @@ function createState(
     member,
     dashboard: createDashboard(),
     selectedHouse: 'citizenship',
-    disabledHouseOptions: status === 'onboarding_required' ? ['alignment'] : [],
     onboardingStepId: undefined,
     profileDraft: {},
     stakeAmountLabel: '250 G$',
@@ -130,6 +140,13 @@ function createState(
       { id: 'finalize', title: 'Finalize governance access', status: 'pending' },
     ],
     registrationHash: null,
+    transaction: { kind: null, status: 'idle', hash: null, error: null },
+    unstakeAvailability: {
+      canUnstake: false,
+      unlockAt: Date.UTC(2026, 8, 1, 12),
+      disabledReason: 'Membership remains locked until the current governance term has passed.',
+    },
+    lifecycleNotice: null,
     error: null,
     ...overrides,
   }
@@ -145,7 +162,7 @@ function createAdapterFactory(state: GovernanceWidgetAdapterState): GovernanceWi
       retry: async () => {},
       selectHouse: () => {},
       register: async () => {},
-      restake: async () => {},
+      unstake: async () => {},
       openVote: () => {},
       closeVote: () => {},
       setVoteAllocation: () => {},
@@ -197,12 +214,11 @@ export const LoadingConnected: Story = {
   render: () => <RuntimeStory state={createState('loading')} />,
 }
 
-export const OnboardingRequiredHoaUnavailable: Story = {
+export const OnboardingHouseSelection: Story = {
   render: () => (
     <RuntimeStory
       state={createState('onboarding_required', {
         onboardingStepId: 'house',
-        disabledHouseOptions: ['alignment'],
         identityStatus: 'verified',
       })}
     />
@@ -217,6 +233,25 @@ export const ActiveCitizenship: Story = {
   render: () => <RuntimeStory state={createState('active_citizenship')} />,
 }
 
+export const UpcomingVote: Story = {
+  render: () => (
+    <RuntimeStory
+      state={createState('active_citizenship', {
+        dashboard: createDashboard({
+          alignmentVoting: {
+            ...createDashboard().alignmentVoting,
+            title: 'Upcoming Alignment vote',
+            summaryLabel: 'Next window starts Aug 1, 2026',
+            isVotingOpen: false,
+            canVote: false,
+            disabledReason: 'Voting is currently closed.',
+          },
+        }),
+      })}
+    />
+  ),
+}
+
 export const ActiveAlignmentInjected: Story = {
   render: () => (
     <RuntimeStory
@@ -281,9 +316,9 @@ export const VoteClosedExecuted: Story = {
             canVote: false,
             summaryLabel: 'Final units executed',
             finalizedUnits: {
-              'food-chain': '420000',
-              'web3-literacy': '310000',
-              'civic-onboarding': '270000',
+              [alignmentRecipients[0]]: '420000',
+              [alignmentRecipients[1]]: '310000',
+              [alignmentRecipients[2]]: '270000',
             },
             disabledReason: 'Voting has closed and final FlowSplitter units are read-only.',
           },
@@ -332,8 +367,96 @@ export const UnsupportedChain: Story = {
   render: () => <RuntimeStory state={createState('unsupported_chain')} />,
 }
 
-export const RestakeRequired: Story = {
-  render: () => <RuntimeStory state={createState('restake_required')} />,
+export const ActiveMembershipUnstakeReady: Story = {
+  render: () => (
+    <RuntimeStory
+      state={createState('active_citizenship', {
+        unstakeAvailability: {
+          canUnstake: true,
+          unlockAt: Date.UTC(2026, 3, 1, 12),
+        },
+      })}
+    />
+  ),
+}
+
+export const UnstakeWalletConfirmation: Story = {
+  render: () => (
+    <RuntimeStory
+      state={createState('active_alignment', {
+        transaction: {
+          kind: 'unstake',
+          status: 'wallet_confirmation',
+          hash: null,
+          error: null,
+        },
+        unstakeAvailability: { canUnstake: true, unlockAt: Date.UTC(2026, 3, 1, 12) },
+      })}
+    />
+  ),
+}
+
+export const UnstakeSubmitted: Story = {
+  render: () => (
+    <RuntimeStory
+      state={createState('active_alignment', {
+        transaction: {
+          kind: 'unstake',
+          status: 'submitted',
+          hash: '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
+          error: null,
+        },
+        unstakeAvailability: { canUnstake: true, unlockAt: Date.UTC(2026, 3, 1, 12) },
+      })}
+    />
+  ),
+}
+
+export const UnstakeRejected: Story = {
+  render: () => (
+    <RuntimeStory
+      state={createState('active_citizenship', {
+        transaction: {
+          kind: 'unstake',
+          status: 'rejected',
+          hash: null,
+          error: 'Transaction rejected in the wallet.',
+        },
+        unstakeAvailability: { canUnstake: true, unlockAt: Date.UTC(2026, 3, 1, 12) },
+      })}
+    />
+  ),
+}
+
+export const UnstakeReverted: Story = {
+  render: () => (
+    <RuntimeStory
+      state={createState('active_citizenship', {
+        transaction: {
+          kind: 'unstake',
+          status: 'reverted',
+          hash: '0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb',
+          error: 'The governance contract rejected this action. Review your details and try again.',
+        },
+        unstakeAvailability: { canUnstake: true, unlockAt: Date.UTC(2026, 3, 1, 12) },
+      })}
+    />
+  ),
+}
+
+export const UnstakedReturnsToOnboarding: Story = {
+  render: () => (
+    <RuntimeStory
+      state={createState('onboarding_required', {
+        identityStatus: 'verified',
+        lifecycleNotice: 'Membership unstaked successfully. You can now join a governance house again.',
+      })}
+    />
+  ),
+}
+
+export const RevokedMembership: Story = {
+  render: () => <RuntimeStory state={createState('revoked')} />,
 }
 
 export const FriendlyContractError: Story = {
@@ -345,3 +468,24 @@ export const FriendlyContractError: Story = {
     />
   ),
 }
+
+export const RealAdapterMockedRuntime: Story = {
+  render: () => {
+    const injectedProvider = getInjectedEip1193Provider()
+    const provider = isInjectedProviderUsable(injectedProvider)
+      ? injectedProvider
+      : createCustodialEip1193Provider()
+
+    return (
+      <GovernanceWidget
+        provider={provider}
+        celoRpcUrl="/mock-governance-rpc"
+        addresses={{
+          housesAddress: '0x4444444444444444444444444444444444444444',
+          goodIdAddress: '0x5555555555555555555555555555555555555555',
+        }}
+        testId="GovernanceWidget-real-adapter"
+      />
+    )
+  },
+}
diff --git a/packages/governance-widget/src/GovernanceOnboardingWidget.tsx b/packages/governance-widget/src/GovernanceOnboardingWidget.tsx
index e0272f63..4439c7a8 100644
--- a/packages/governance-widget/src/GovernanceOnboardingWidget.tsx
+++ b/packages/governance-widget/src/GovernanceOnboardingWidget.tsx
@@ -2,27 +2,23 @@ import { useMemo } from 'react'
 import { PageWizardProvider } from '@goodwidget/ui'
 import { GovernanceOnboardingFlow } from './onboarding/GovernanceOnboardingFlow'
 import { DEFAULT_FINAL_ACTIONS, DEFAULT_TRANSACTION_STEPS, ONBOARDING_STEPS } from './onboarding/constants'
+import { HOUSE_COPY } from './onboarding/copy'
 import type {
   GovernanceOnboardingStepId,
   GovernanceOnboardingWidgetProps,
   GovernanceWizardData,
 } from './types'
 
-/**
- * GovernanceOnboardingWidget keeps the five onboarding pages UI-only for now.
- * The component owns light/dark-safe visuals, simple local navigation, and a
- * presentational state contract that stories and later runtime integrations can drive.
- */
 export function GovernanceOnboardingWidget({
   currentStepId,
   initialStepId = 'welcome',
   identityStatus = 'verified',
   walletAddress,
   initialHouse,
-  disabledHouseOptions = [],
   initialProfileDraft,
   initialFieldErrors = {},
-  stakeAmountLabel = '250 G$',
+  stakeAmountLabel,
+  stakeAmountLabels,
   transactionSteps = DEFAULT_TRANSACTION_STEPS,
   finalActions = DEFAULT_FINAL_ACTIONS,
   dataTestId,
@@ -39,6 +35,12 @@ export function GovernanceOnboardingWidget({
     }),
     [initialHouse, initialProfileDraft],
   )
+  const resolvedStakeAmountLabels = stakeAmountLabels ?? (stakeAmountLabel
+    ? { citizenship: stakeAmountLabel, alignment: stakeAmountLabel }
+    : {
+        citizenship: HOUSE_COPY.citizenship.defaultStakeAmount,
+        alignment: HOUSE_COPY.alignment.defaultStakeAmount,
+      })
 
   return (
     <PageWizardProvider
@@ -51,9 +53,8 @@ export function GovernanceOnboardingWidget({
       <GovernanceOnboardingFlow
         identityStatus={identityStatus}
         walletAddress={walletAddress}
-        disabledHouseOptions={disabledHouseOptions}
         initialFieldErrors={initialFieldErrors}
-        stakeAmountLabel={stakeAmountLabel}
+        stakeAmountLabels={resolvedStakeAmountLabels}
         transactionSteps={transactionSteps}
         finalActions={finalActions}
         onHouseChange={onHouseChange}
diff --git a/packages/governance-widget/src/GovernanceWidget.tsx b/packages/governance-widget/src/GovernanceWidget.tsx
index beb1e3a9..e1ecc7b3 100644
--- a/packages/governance-widget/src/GovernanceWidget.tsx
+++ b/packages/governance-widget/src/GovernanceWidget.tsx
@@ -1,5 +1,5 @@
 import { useMemo } from 'react'
-import { Button, ButtonText, Card, Heading, Input, Spinner, Text, XStack, YStack } from '@goodwidget/ui'
+import { Button, ButtonText, Card, Heading, Icon, Input, Spinner, Text, XStack, YStack } from '@goodwidget/ui'
 import { AlignmentVotingProposalCard } from './AlignmentVotingProposalCard'
 import { BalanceCard } from './BalanceCard'
 import { FundingDistributionChart } from './FundingDistributionChart'
@@ -7,13 +7,16 @@ import { GovernanceOnboardingWidget } from './GovernanceOnboardingWidget'
 import { GovernanceWidgetProvider } from './GovernanceWidgetProvider'
 import { ImpactCard } from './ImpactCard'
 import { useGovernanceAdapter } from './adapter'
-import type {
-  GovernanceWidgetAdapterActions,
-  GovernanceWidgetAdapterFactoryInput,
-  GovernanceWidgetAdapterState,
-  GovernanceWidgetProps,
+import {
+  getGovernanceVotingDisabledReason,
+  type GovernanceWidgetAdapterActions,
+  type GovernanceWidgetAdapterFactoryInput,
+  type GovernanceWidgetAdapterResult,
+  type GovernanceWidgetAdapterState,
+  type GovernanceWidgetProps,
 } from './widgetRuntimeContract'
 import { isActiveStatus } from './adapter'
+import { formatStakeAmount } from './sdks/contracts'
 
 function formatMemberDate(timestamp: number | null): string {
   if (!timestamp) return 'Not available'
@@ -22,6 +25,17 @@ function formatMemberDate(timestamp: number | null): string {
   )
 }
 
+function formatMemberDateTime(timestamp: number | null): string {
+  if (!timestamp) return 'Not available'
+  return new Intl.DateTimeFormat('en-US', {
+    month: 'short',
+    day: 'numeric',
+    year: 'numeric',
+    hour: 'numeric',
+    minute: '2-digit',
+  }).format(new Date(timestamp))
+}
+
 function GovernanceHeader({
   state,
   actions,
@@ -32,14 +46,27 @@ function GovernanceHeader({
   const addressLabel = state.address ? `${state.address.slice(0, 6)}…${state.address.slice(-4)}` : null
 
   return (
-    <Card outlined data-testid="GovernanceWidget-header">
+    <YStack
+      backgroundColor="$background"
+      borderBottomWidth={1}
+      borderColor="$borderColor"
+      padding="$4"
+      data-testid="GovernanceWidget-header"
+    >
       <XStack alignItems="center" justifyContent="space-between" gap="$3" flexWrap="wrap">
-        <YStack gap="$1" flex={1} minWidth={220}>
-          <Heading level={3}>GoodDAO Governance</Heading>
-          <Text tone="secondary">
-            Browse governance impact, funding distribution, and active Alignment voting.
-          </Text>
-        </YStack>
+        <XStack alignItems="center" gap="$3" flex={1} minWidth={180}>
+          <YStack
+            width={40}
+            height={40}
+            borderRadius="$full"
+            backgroundColor="$primary"
+            alignItems="center"
+            justifyContent="center"
+          >
+            <Icon name="shield-check" size="sm" color="white" />
+          </YStack>
+          <Heading level={5} color="$primary">GoodDAO</Heading>
+        </XStack>
         {state.address ? (
           <YStack alignItems="flex-end" gap="$1">
             <Text variant="caption" tone="secondary">
@@ -57,7 +84,7 @@ function GovernanceHeader({
           </Button>
         )}
       </XStack>
-    </Card>
+    </YStack>
   )
 }
 
@@ -174,7 +201,8 @@ function PendingAlignmentState({ state }: { state: GovernanceWidgetAdapterState
       <YStack gap="$3">
         <Heading level={4}>Alignment membership pending</Heading>
         <Text tone="secondary">
-          Lorem ipsum dolor sit amet, consectetur adipiscing elit. Your House of Alignment application is waiting for committee approval.
+          Your House of Alignment application is recorded on-chain and is waiting for
+          committee approval. No further transaction is required while it is pending.
         </Text>
         <Text variant="caption" tone="secondary">
           Wallet: {state.address ?? 'Not connected'}
@@ -184,32 +212,84 @@ function PendingAlignmentState({ state }: { state: GovernanceWidgetAdapterState
   )
 }
 
-function RestakeState({
+function MembershipExitState({
   state,
   actions,
 }: {
   state: GovernanceWidgetAdapterState
   actions: GovernanceWidgetAdapterActions
 }) {
+  const transaction = state.transaction.kind === 'unstake' ? state.transaction : null
+  const isPending =
+    transaction?.status === 'wallet_confirmation' ||
+    transaction?.status === 'submitted' ||
+    transaction?.status === 'confirmed'
+  const canSubmit = state.unstakeAvailability.canUnstake && !isPending
+
   return (
-    <Card data-testid="GovernanceWidget-restake">
+    <Card outlined data-testid="GovernanceWidget-unstake">
       <YStack gap="$3">
-        <Heading level={4}>Restore governance membership</Heading>
+        <Heading level={4}>Membership stake</Heading>
         <Text tone="secondary">
-          This member is currently {state.member?.status ?? 'inactive'}. You can restake to rejoin the selected house.
+          Active governance stakes remain locked for one full term. Once the lock expires,
+          unstaking returns your G$ and removes your active membership.
         </Text>
+        <XStack gap="$2" justifyContent="space-between" flexWrap="wrap">
+          <Text variant="caption" tone="secondary">Available from</Text>
+          <Text variant="caption" fontWeight="700">
+            {formatMemberDateTime(state.unstakeAvailability.unlockAt)}
+          </Text>
+        </XStack>
+        {!state.unstakeAvailability.canUnstake ? (
+          <Text variant="caption" tone="secondary" data-testid="GovernanceWidget-unstake-locked">
+            {state.unstakeAvailability.disabledReason}
+          </Text>
+        ) : null}
+        {transaction?.status === 'wallet_confirmation' ? (
+          <Text color="$warning" fontWeight="700">Confirm the unstake transaction in your wallet.</Text>
+        ) : null}
+        {transaction?.status === 'submitted' ? (
+          <Text color="$warning" fontWeight="700">
+            Transaction submitted. Waiting for a successful Celo receipt…
+          </Text>
+        ) : null}
+        {transaction?.status === 'rejected' ||
+        transaction?.status === 'reverted' ||
+        transaction?.status === 'failed' ? (
+          <Text color="$error" fontWeight="700">
+            {transaction.error ?? 'The unstake transaction did not complete.'}
+          </Text>
+        ) : null}
         <Button
+          disabled={!canSubmit}
           onPress={() => {
-            void actions.restake()
+            void actions.unstake()
           }}
         >
-          <ButtonText>Restake {state.stakeAmountLabel}</ButtonText>
+          <ButtonText>{isPending ? 'Unstaking…' : 'Unstake membership'}</ButtonText>
         </Button>
       </YStack>
     </Card>
   )
 }
 
+function RevokedState({ state }: { state: GovernanceWidgetAdapterState }) {
+  return (
+    <Card data-testid="GovernanceWidget-revoked">
+      <YStack gap="$3">
+        <Heading level={4}>Membership revoked</Heading>
+        <Text tone="secondary">
+          This governance membership was revoked and cannot be reactivated from the widget.
+          Contact the GoodDAO governance team if you believe this status is incorrect.
+        </Text>
+        <Text variant="caption" tone="secondary">
+          Wallet: {state.address ?? 'Not connected'}
+        </Text>
+      </YStack>
+    </Card>
+  )
+}
+
 function MemberFooter({ state }: { state: GovernanceWidgetAdapterState }) {
   if (!state.member || !isActiveStatus(state.status)) return null
 
@@ -238,8 +318,21 @@ function GovernanceVoteDetail({
   actions: GovernanceWidgetAdapterActions
 }) {
   const vote = state.dashboard.alignmentVoting
-  const canSubmit = vote.canVote && vote.allocationTotalBps === 10000 && !vote.hasVoted && vote.isVotingOpen
-  const isReadOnly = vote.hasVoted || vote.executed
+  const disabledReason = getGovernanceVotingDisabledReason(vote)
+  const voteTransactionPending =
+    state.transaction.kind === 'vote' &&
+    (
+      state.transaction.status === 'wallet_confirmation' ||
+      state.transaction.status === 'submitted' ||
+      state.transaction.status === 'confirmed'
+    )
+  const canSubmit =
+    vote.canVote &&
+    vote.allocationTotalBps === 10000 &&
+    !vote.hasVoted &&
+    vote.isVotingOpen &&
+    !voteTransactionPending
+  const isReadOnly = vote.hasVoted || vote.executed || voteTransactionPending
 
   return (
     <Card data-testid="GovernanceWidget-vote-detail">
@@ -251,7 +344,8 @@ function GovernanceVoteDetail({
           </Button>
         </XStack>
         <Text tone="secondary">
-          Placeholder voting detail. Enter allocation basis points; totals must equal 10,000 before voting.
+          Allocate basis points across the recipients captured when this vote opened.
+          Your allocation must total exactly 10,000 basis points.
         </Text>
         <YStack gap="$3">
           {vote.options.map((option) =>
@@ -278,7 +372,21 @@ function GovernanceVoteDetail({
             Already voted — this contract does not support ballot replacement.
           </Text>
         ) : null}
-        {!canSubmit ? <Text tone="secondary">{vote.disabledReason ?? 'Voting is unavailable.'}</Text> : null}
+        {!canSubmit && !voteTransactionPending ? (
+          <Text tone="secondary">{disabledReason ?? 'Voting is unavailable.'}</Text>
+        ) : null}
+        {state.transaction.kind === 'vote' && state.transaction.status === 'wallet_confirmation' ? (
+          <Text color="$warning" fontWeight="700">Confirm the vote in your wallet.</Text>
+        ) : null}
+        {state.transaction.kind === 'vote' && state.transaction.status === 'submitted' ? (
+          <Text color="$warning" fontWeight="700">Vote submitted. Waiting for confirmation…</Text>
+        ) : null}
+        {state.transaction.kind === 'vote' && state.transaction.status === 'confirmed' ? (
+          <Text color="$success" fontWeight="700">Vote confirmed on Celo.</Text>
+        ) : null}
+        {state.transaction.kind === 'vote' && state.transaction.error ? (
+          <Text color="$error" fontWeight="700">{state.transaction.error}</Text>
+        ) : null}
         <Button
           disabled={!canSubmit}
           onPress={() => {
@@ -292,17 +400,13 @@ function GovernanceVoteDetail({
   )
 }
 
-function GovernanceWidgetContent({
-  adapterFactory,
-  adapterInput,
+function GovernanceWidgetView({
+  adapter,
   testId,
 }: {
-  adapterFactory?: GovernanceWidgetProps['adapterFactory']
-  adapterInput: GovernanceWidgetAdapterFactoryInput
+  adapter: GovernanceWidgetAdapterResult
   testId?: string
 }) {
-  const defaultAdapter = useGovernanceAdapter(adapterInput)
-  const adapter = adapterFactory ? adapterFactory(adapterInput) : defaultAdapter
   const { state, actions } = adapter
   const shouldShowDashboard =
     state.status === 'disconnected' ||
@@ -315,35 +419,78 @@ function GovernanceWidgetContent({
     <YStack gap="$4" width="100%" data-testid={testId ?? 'GovernanceWidget'}>
       <GovernanceHeader state={state} actions={actions} />
       <RuntimeNotice state={state} actions={actions} />
+      {state.error && state.status !== 'friendly_error' && state.transaction.status === 'idle' ? (
+        <Card data-testid="GovernanceWidget-action-error">
+          <YStack gap="$2">
+            <Text color="$error" fontWeight="700">Governance action unavailable</Text>
+            <Text tone="secondary">{state.error}</Text>
+          </YStack>
+        </Card>
+      ) : null}
       {state.status === 'vote_detail' ? <GovernanceVoteDetail state={state} actions={actions} /> : null}
       {state.status === 'onboarding_required' ? (
-        <GovernanceOnboardingWidget
-          currentStepId={state.onboardingStepId}
-          identityStatus={state.identityStatus}
-          walletAddress={state.address ?? undefined}
-          initialHouse={state.selectedHouse}
-          disabledHouseOptions={state.disabledHouseOptions}
-          initialProfileDraft={state.profileDraft}
-          stakeAmountLabel={state.stakeAmountLabel}
-          transactionSteps={state.transactionSteps}
-          dataTestId="GovernanceWidget-onboarding"
-          onHouseChange={actions.selectHouse}
-          onIdentityVerificationPress={() => {
-            void actions.startIdentityVerification()
-          }}
-          onProfileSubmit={(profileDraft) => {
-            void actions.register(profileDraft)
-          }}
-        />
+        <YStack gap="$4">
+          {state.lifecycleNotice ? (
+            <Card data-testid="GovernanceWidget-lifecycle-notice">
+              <Text color="$success" fontWeight="700">{state.lifecycleNotice}</Text>
+            </Card>
+          ) : null}
+          <GovernanceOnboardingWidget
+            currentStepId={state.onboardingStepId}
+            identityStatus={state.identityStatus}
+            walletAddress={state.address ?? undefined}
+            initialHouse={state.selectedHouse}
+            initialProfileDraft={state.profileDraft}
+            stakeAmountLabel={state.stakeAmountLabel}
+            stakeAmountLabels={{
+              citizenship: formatStakeAmount(state.minimumStakeAmounts.citizenship),
+              alignment: formatStakeAmount(state.minimumStakeAmounts.alignment),
+            }}
+            transactionSteps={state.transactionSteps}
+            dataTestId="GovernanceWidget-onboarding"
+            onHouseChange={actions.selectHouse}
+            onIdentityVerificationPress={() => {
+              void actions.startIdentityVerification()
+            }}
+            onProfileSubmit={(profileDraft) => {
+              void actions.register(profileDraft)
+            }}
+          />
+        </YStack>
       ) : null}
       {state.status === 'pending_alignment' ? <PendingAlignmentState state={state} /> : null}
-      {state.status === 'restake_required' ? <RestakeState state={state} actions={actions} /> : null}
+      {state.status === 'revoked' ? <RevokedState state={state} /> : null}
       {shouldShowDashboard ? <GovernanceDashboard state={state} actions={actions} /> : null}
       <MemberFooter state={state} />
+      {isActiveStatus(state.status) ? <MembershipExitState state={state} actions={actions} /> : null}
     </YStack>
   )
 }
 
+function DefaultGovernanceWidgetContent({
+  adapterInput,
+  testId,
+}: {
+  adapterInput: GovernanceWidgetAdapterFactoryInput
+  testId?: string
+}) {
+  const adapter = useGovernanceAdapter(adapterInput)
+  return <GovernanceWidgetView adapter={adapter} testId={testId} />
+}
+
+function InjectedGovernanceWidgetContent({
+  adapterFactory,
+  adapterInput,
+  testId,
+}: {
+  adapterFactory: NonNullable<GovernanceWidgetProps['adapterFactory']>
+  adapterInput: GovernanceWidgetAdapterFactoryInput
+  testId?: string
+}) {
+  const adapter = adapterFactory(adapterInput)
+  return <GovernanceWidgetView adapter={adapter} testId={testId} />
+}
+
 export function GovernanceWidget({
   provider,
   themeOverrides,
@@ -367,11 +514,15 @@ export function GovernanceWidget({
       config={config}
       defaultTheme={defaultTheme}
     >
-      <GovernanceWidgetContent
-        adapterFactory={adapterFactory}
-        adapterInput={adapterInput}
-        testId={testId}
-      />
+      {adapterFactory ? (
+        <InjectedGovernanceWidgetContent
+          adapterFactory={adapterFactory}
+          adapterInput={adapterInput}
+          testId={testId}
+        />
+      ) : (
+        <DefaultGovernanceWidgetContent adapterInput={adapterInput} testId={testId} />
+      )}
     </GovernanceWidgetProvider>
   )
 }
diff --git a/packages/governance-widget/src/adapter.ts b/packages/governance-widget/src/adapter.ts
index 88e2fa21..0e89e241 100644
--- a/packages/governance-widget/src/adapter.ts
+++ b/packages/governance-widget/src/adapter.ts
@@ -1,51 +1,47 @@
-import { useCallback, useEffect, useMemo, useState } from 'react'
+import { useCallback, useMemo } from 'react'
 import { useWallet } from '@goodwidget/core'
-import { getAddress, isAddress, type Address, type Hex } from 'viem'
-import type { StepperStepItem } from '@goodwidget/ui'
-import type { GovernanceHouse, GovernanceProfileDraft, RankedVotingOption } from './types'
+import { getAddress } from 'viem'
+import type { GovernanceDashboardState } from './widgetRuntimeContract'
 import type {
-  GovernanceDashboardState,
   GovernanceWidgetAdapterActions,
   GovernanceWidgetAdapterFactoryInput,
   GovernanceWidgetAdapterResult,
   GovernanceWidgetAdapterState,
   GovernanceWidgetStatus,
+  GovernanceTransactionState,
   GovernanceVotingState,
 } from './widgetRuntimeContract'
 import {
   CELO_CHAIN_ID,
-  ZERO_ADDRESS,
   createGovernancePublicClient,
-  createGovernanceWalletClient,
-  formatStakeAmount,
   requestCeloMainnetSwitch,
   resolveGovernanceAddresses,
-  type GovernanceMemberRecord,
 } from './sdks/contracts'
+import type { GovernanceStakeRequirements } from './sdks/contractReads'
 import {
-  readFlowSplitterConfig,
-  readGovernanceMembership,
-  readGovernanceSchedule,
-  readGovernanceVote,
-  stakeRequirementLabel,
-  type GovernanceSchedule,
-  type GovernanceStakeRequirements,
-} from './sdks/contractReads'
-import { castGovernanceVote, registerWithTransferAndCall, restakeWithTransferAndCall, type GovernanceTransactionStage } from './sdks/transactions'
-import { fetchFundingReceivedSoFar } from './sdks/funding'
-import { createGovernanceIdentitySdk, createGovernanceIdentityVerificationLink } from './sdks/identity'
+  createTransactionSteps,
+  friendlyGovernanceError,
+  isActiveStatus,
+  useGovernanceMembership,
+} from './hooks/useGovernanceMembership'
+import {
+  createEmptyVotingState,
+  useGovernanceVoting,
+} from './hooks/useGovernanceVoting'
+import {
+  createFundingLoadingState,
+  useGovernanceFunding,
+} from './hooks/useGovernanceFunding'
 
 const IMPACT_METRICS: GovernanceDashboardState['impact'] = {
   title: 'Distributed',
   metrics: [
-    { label: 'UBI Pool', amount: { value: 'Unavailable', token: '' } },
-    {
-      label: 'Impact Pool',
-      amount: { value: 'Live total below', token: '' },
-    },
+    { label: 'UBI Pool', amount: { value: '—', token: 'G$' } },
+    { label: 'Impact Pool', amount: { value: '—', token: 'G$' } },
   ],
   description:
     'Empowering people worldwide through transparent, decentralized funding for public goods.',
+  ctaLabel: 'View Impact Report Q3',
 }
 
 const EMPTY_STAKES: GovernanceStakeRequirements = {
@@ -53,124 +49,6 @@ const EMPTY_STAKES: GovernanceStakeRequirements = {
   alignment: 0n,
 }
 
-function shortAddress(address: Address): string {
-  return `${address.slice(0, 6)}…${address.slice(-4)}`
-}
-
-function createTransactionSteps(stage: GovernanceTransactionStage | 'idle' | 'failed', failedMessage?: string): StepperStepItem[] {
-  const statuses: Record<string, StepperStepItem['status']> = {
-    prepare: stage === 'idle' ? 'active' : 'completed',
-    approve: stage === 'wallet_confirmation' ? 'active' : stage === 'idle' ? 'pending' : 'completed',
-    stake: stage === 'submitted' ? 'active' : stage === 'confirmed' ? 'completed' : stage === 'failed' ? 'failed' : 'pending',
-    finalize: stage === 'confirmed' ? 'completed' : 'pending',
-  }
-
-  return [
-    {
-      id: 'prepare',
-      title: 'Prepare wallet balance',
-      description: 'Keep the required G$ amount available before the staking transaction starts.',
-      status: statuses.prepare,
-    },
-    {
-      id: 'approve',
-      title: 'Confirm in wallet',
-      description: 'Approve the G$ transferAndCall transaction from your wallet.',
-      status: statuses.approve,
-    },
-    {
-      id: 'stake',
-      title: 'Transaction submitted',
-      description: failedMessage ?? 'Wait for the Celo transaction receipt before continuing.',
-      status: statuses.stake,
-    },
-    {
-      id: 'finalize',
-      title: 'Confirmed on-chain',
-      status: statuses.finalize,
-    },
-  ]
-}
-
-function nextVotingWindowLabel(schedule: GovernanceSchedule, nowMs = Date.now()): string {
-  if (!schedule.cycleStartTime || schedule.termDurationSeconds === 0n) {
-    return 'Contract schedule unavailable'
-  }
-  const termMs = Number(schedule.termDurationSeconds) * 1000
-  const cycleStart = schedule.cycleStartTime
-  const nextStart = nowMs < cycleStart ? cycleStart : cycleStart + (Math.floor((nowMs - cycleStart) / termMs) + 1) * termMs
-  return `Next window starts ${new Intl.DateTimeFormat('en-US', { month: 'short', day: 'numeric', year: 'numeric' }).format(new Date(nextStart))}`
-}
-
-function createVotingState(params: {
-  status: GovernanceWidgetStatus
-  member: GovernanceMemberRecord | null
-  identityRoot: Address
-  activeAlignment: Address[]
-  voteId: bigint
-  isVotingOpen: boolean
-  voteConfig: { startTime: number | null; endTime: number | null; executedAt: number | null; executed: boolean }
-  recipients: Address[]
-  hasVoted: boolean
-  finalizedUnits: Record<string, bigint>
-  schedule: GovernanceSchedule
-}): GovernanceVotingState {
-  const recipients = params.recipients.map((recipient) => getAddress(recipient))
-  const totalUnits = Object.values(params.finalizedUnits).reduce((total, amount) => total + amount, 0n)
-  const options: RankedVotingOption[] = recipients.map((recipient) => {
-    const units = params.finalizedUnits[recipient.toLowerCase()] ?? params.finalizedUnits[recipient] ?? 0n
-    return {
-      id: recipient,
-      label: shortAddress(recipient),
-      percentage: totalUnits > 0n ? Number((units * 100n) / totalUnits) : 0,
-    }
-  })
-  const allocationsBps = Object.fromEntries(options.map((option) => [option.id, 0]))
-  const isActiveMember = params.member?.status === 'active'
-  const hasCitizenIdentity = params.member?.house !== 'citizenship' || params.identityRoot.toLowerCase() !== ZERO_ADDRESS
-  const canVote = Boolean(isActiveMember && hasCitizenIdentity && params.isVotingOpen && !params.hasVoted && recipients.length > 0)
-
-  let title = 'Alignment vote'
-  let summaryLabel = 'Allocate 10,000 bps to active House of Alignment recipients'
-  let disabledReason: string | undefined
-
-  if (!params.isVotingOpen) {
-    title = 'Upcoming Alignment vote'
-    summaryLabel = nextVotingWindowLabel(params.schedule)
-    disabledReason = 'Voting is currently closed.'
-  } else if (params.activeAlignment.length === 0) {
-    disabledReason = 'No House of Alignment members have been assigned yet. Voting will open shortly.'
-  } else if (params.hasVoted) {
-    disabledReason = 'You already voted in this allocation cycle.'
-  } else if (!isActiveMember) {
-    disabledReason = 'Only active members can vote.'
-  } else if (!hasCitizenIdentity) {
-    disabledReason = 'Verify your GoodID before voting as a Citizen.'
-  }
-
-  if (params.voteConfig.executed) {
-    title = 'Executed Alignment vote'
-    summaryLabel = 'Final units executed'
-    disabledReason = 'This vote has already been executed.'
-  }
-
-  return {
-    voteId: params.voteId.toString(),
-    title,
-    summaryLabel,
-    options,
-    recipients,
-    allocationsBps,
-    allocationTotalBps: 0,
-    canVote,
-    hasVoted: params.hasVoted,
-    isVotingOpen: params.isVotingOpen,
-    executed: params.voteConfig.executed,
-    finalizedUnits: Object.fromEntries(Object.entries(params.finalizedUnits).map(([recipient, units]) => [recipient, units.toString()])),
-    disabledReason,
-  }
-}
-
 function createDashboardState(params: {
   activeMemberCount?: number
   voting?: GovernanceVotingState
@@ -186,37 +64,14 @@ function createDashboardState(params: {
       metadataType: 'time-window',
       metadata: { label: 'Active members only', tone: 'muted', icon: 'info' },
     },
-    alignmentVoting:
-      params.voting ??
-      {
-        voteId: '0',
-        title: 'Upcoming Alignment vote',
-        summaryLabel: 'Contract schedule unavailable',
-        options: [],
-        recipients: [],
-        allocationsBps: {},
-        allocationTotalBps: 0,
-        canVote: false,
-        hasVoted: false,
-        isVotingOpen: false,
-        executed: false,
-        finalizedUnits: {},
-        disabledReason: 'Connect a wallet to load governance voting state.',
-      },
-    fundingDistribution:
-      params.funding ??
-      {
-        title: 'Funding received so far',
-        centerLabel: 'Loading live funding',
-        totalAmount: { value: '0', token: 'G$', isStreaming: true, streamLabel: 'Loading Superfluid streams' },
-        projects: [],
-        isStreaming: true,
-        emptyStateLabel: 'Loading funding streams…',
-      },
+    alignmentVoting: params.voting ?? createEmptyVotingState(),
+    fundingDistribution: params.funding ?? createFundingLoadingState(),
   }
 }
 
-function createInitialState(status: GovernanceWidgetStatus = 'disconnected'): GovernanceWidgetAdapterState {
+function createInitialState(
+  status: GovernanceWidgetStatus = 'disconnected',
+): GovernanceWidgetAdapterState {
   return {
     status,
     address: null,
@@ -226,66 +81,36 @@ function createInitialState(status: GovernanceWidgetStatus = 'disconnected'): Go
     member: null,
     dashboard: createDashboardState(),
     selectedHouse: 'citizenship',
-    disabledHouseOptions: ['alignment'],
     onboardingStepId: undefined,
     profileDraft: {},
     stakeAmountLabel: '0 G$',
     minimumStakeAmounts: EMPTY_STAKES,
     transactionSteps: createTransactionSteps('idle'),
     registrationHash: null,
+    transaction: { kind: null, status: 'idle', hash: null, error: null },
+    unstakeAvailability: {
+      canUnstake: false,
+      unlockAt: null,
+      disabledReason: 'Only active members can unstake.',
+    },
+    lifecycleNotice: null,
     error: null,
   }
 }
 
-function friendlyGovernanceError(err: unknown): string {
-  if (!(err instanceof Error)) {
-    return 'Something went wrong. Please try again.'
-  }
-
-  const message = err.message
-  if (message.includes('User rejected') || message.includes('4001')) {
-    return 'Transaction rejected in the wallet.'
-  }
-  if (message.includes('Already voted')) {
-    return 'You already voted in this allocation cycle.'
-  }
-  if (message.includes('Alloc != 10000')) {
-    return 'Allocation totals must equal exactly 10,000 basis points.'
-  }
-  if (message.includes('insufficient funds')) {
-    return 'Your wallet does not have enough funds for this governance action.'
-  }
-  if (message.includes('Not HoA eligible')) {
-    return 'This wallet is not currently eligible for House of Alignment registration.'
-  }
-  if (message.includes('revert') || message.includes('reverted')) {
-    return 'The governance contract rejected this action. Review your details and try again.'
-  }
-  if (message.includes('fetch') || message.includes('network') || message.includes('HTTP')) {
-    return 'Unable to reach Celo Mainnet. Check your connection and try again.'
-  }
-
-  return 'Unable to complete the governance action. Please try again.'
-}
-
-function statusFromMember(member: GovernanceMemberRecord | null): GovernanceWidgetStatus {
-  if (!member || member.status === 'none') return 'onboarding_required'
-  if (member.status === 'pending' && member.house === 'alignment') return 'pending_alignment'
-  if (member.status === 'active' && member.house === 'alignment') return 'active_alignment'
-  if (member.status === 'active') return 'active_citizenship'
-  if (member.status === 'revoked' || member.status === 'unstaked') return 'restake_required'
-  return 'onboarding_required'
+function isPendingTransaction(transaction: GovernanceTransactionState): boolean {
+  return transaction.status === 'wallet_confirmation' || transaction.status === 'submitted'
 }
 
-function isActiveStatus(status: GovernanceWidgetStatus): boolean {
-  return status === 'active_alignment' || status === 'active_citizenship'
-}
-
-function transactionStageToStep(stage: GovernanceTransactionStage, hash?: Hex): Partial<GovernanceWidgetAdapterState> {
-  return {
-    registrationHash: hash ?? null,
-    transactionSteps: createTransactionSteps(stage),
-  }
+export function selectGovernanceTransaction(
+  membershipTransaction: GovernanceTransactionState,
+  votingTransaction: GovernanceTransactionState,
+  isVoteDetailOpen = false,
+): GovernanceTransactionState {
+  if (isPendingTransaction(votingTransaction)) return votingTransaction
+  if (isPendingTransaction(membershipTransaction)) return membershipTransaction
+  if (isVoteDetailOpen && votingTransaction.status !== 'idle') return votingTransaction
+  return membershipTransaction.status !== 'idle' ? membershipTransaction : votingTransaction
 }
 
 export function useGovernanceAdapter({
@@ -294,376 +119,173 @@ export function useGovernanceAdapter({
   addresses: addressOverrides,
 }: GovernanceWidgetAdapterFactoryInput = {}): GovernanceWidgetAdapterResult {
   const { address, chainId, provider, connect } = useWallet()
-  const [state, setState] = useState<GovernanceWidgetAdapterState>(() => createInitialState())
-  const publicClient = useMemo(() => createGovernancePublicClient(celoRpcUrl), [celoRpcUrl])
-  const addresses = useMemo(() => resolveGovernanceAddresses(addressOverrides), [addressOverrides])
-  const account = address as Address | null
-
-  const loadRuntimeState = useCallback(async () => {
-    if (!account) {
-      setState((previous) => ({ ...previous, ...createInitialState('disconnected'), chainId: chainId ?? null }))
-      return
-    }
-
-    if (chainId !== CELO_CHAIN_ID) {
-      setState((previous) => ({
-        ...previous,
-        status: 'unsupported_chain',
-        address: account,
-        chainId: chainId ?? null,
-        error: null,
-      }))
-      return
-    }
-
-    if (!addresses.houses) {
-      setState((previous) => ({
-        ...previous,
-        status: 'friendly_error',
-        address: account,
-        chainId,
-        error: 'Governance contract address is not configured yet.',
-      }))
-      return
-    }
-
-    setState((previous) => ({ ...previous, status: 'loading', address: account, chainId, error: null }))
-
-    try {
-      const membership = await readGovernanceMembership({
-        publicClient,
-        housesAddress: addresses.houses,
-        goodIdAddress: addresses.goodId,
-        account,
-      })
-      const status = statusFromMember(membership.member)
-      const schedule = await readGovernanceSchedule({ publicClient, housesAddress: addresses.houses })
-      const voterKey = membership.member.house === 'citizenship' && membership.identityRoot.toLowerCase() !== ZERO_ADDRESS
-        ? membership.identityRoot
-        : account
-      const vote = await readGovernanceVote({
-        publicClient,
-        housesAddress: addresses.houses,
-        voterKey,
-        activeAlignment: membership.activeAlignment,
-      })
-      const votingState = createVotingState({
-        status,
-        member: membership.member,
-        identityRoot: membership.identityRoot,
-        activeAlignment: membership.activeAlignment,
-        voteId: vote.voteId,
-        isVotingOpen: vote.isVotingPeriod,
-        voteConfig: vote.voteConfig,
-        recipients: vote.recipients,
-        hasVoted: vote.hasVoted,
-        finalizedUnits: vote.finalizedUnits,
-        schedule,
-      })
-      let funding: GovernanceDashboardState['fundingDistribution'] = {
-        title: 'Funding received so far',
-        centerLabel: 'Funding unavailable',
-        totalAmount: { value: '0', token: 'G$', isStreaming: false, streamLabel: 'Superfluid stream data unavailable' },
-        projects: [],
-        emptyStateLabel: 'Funding data is unavailable right now.',
-      }
-
-      try {
-        const flowConfig = await readFlowSplitterConfig({ publicClient, housesAddress: addresses.houses })
-        if (flowConfig.poolAddress.toLowerCase() === ZERO_ADDRESS) {
-          funding = {
-            title: 'Funding received so far',
-            centerLabel: 'No receiver configured',
-            totalAmount: { value: '0', token: 'G$', isStreaming: false, streamLabel: 'No FlowSplitter pool receiver yet' },
-            projects: [],
-            emptyStateLabel: 'No funding receiver has been configured yet.',
-          }
-        } else {
-          const fundingTotal = await fetchFundingReceivedSoFar({ receiver: flowConfig.poolAddress, token: addresses.gToken })
-          funding = {
-            title: 'Funding received so far',
-            centerLabel: fundingTotal.streamCount > 0 ? 'Live Superfluid total' : 'No streams yet',
-            totalAmount: {
-              value: fundingTotal.formattedAmount,
-              token: 'G$',
-              isStreaming: fundingTotal.streamCount > 0,
-              streamLabel: fundingTotal.streamCount > 0 ? `${fundingTotal.streamCount} inbound stream${fundingTotal.streamCount === 1 ? '' : 's'}` : 'No inbound streams found',
-            },
-            projects: [],
-            isStreaming: fundingTotal.streamCount > 0,
-            emptyStateLabel: fundingTotal.streamCount > 0 ? 'Distribution breakdown unavailable until outgoing stream data exists.' : 'No funding streams have been received yet.',
-          }
-        }
-      } catch {
-        // Keep membership and voting usable if the subgraph is unavailable.
-      }
-
-      const selectedHouse = membership.member.status === 'none' ? state.selectedHouse : membership.member.house
-      setState((previous) => ({
-        ...previous,
-        status,
-        address: account,
-        chainId,
-        identityStatus: membership.identityRoot.toLowerCase() !== ZERO_ADDRESS ? 'verified' : 'unverified',
-        member: membership.member,
-        dashboard: createDashboardState({
-          activeMemberCount: membership.activeCitizens.length + membership.activeAlignment.length,
-          voting: votingState,
-          funding,
-        }),
-        selectedHouse,
-        disabledHouseOptions: membership.hoaEligibility.isEligible ? [] : ['alignment'],
-        minimumStakeAmounts: membership.minimumStakes,
-        stakeAmountLabel: stakeRequirementLabel(membership.minimumStakes, selectedHouse),
-        error: null,
-      }))
-    } catch (err: unknown) {
-      setState((previous) => ({
-        ...previous,
-        status: 'friendly_error',
-        address: account,
-        chainId,
-        error: friendlyGovernanceError(err),
-      }))
-    }
-  }, [account, addresses, chainId, publicClient, state.selectedHouse])
-
-  useEffect(() => {
-    void loadRuntimeState()
-  }, [loadRuntimeState])
-
-  useEffect(() => {
-    if (!account || chainId !== CELO_CHAIN_ID || !addresses.houses) return undefined
-    const interval = globalThis.setInterval(() => {
-      void loadRuntimeState()
-    }, 30_000)
-    return () => globalThis.clearInterval(interval)
-  }, [account, addresses.houses, chainId, loadRuntimeState])
-
-  const switchToCelo = useCallback(async () => {
-    try {
-      await requestCeloMainnetSwitch(provider)
-    } finally {
-      await loadRuntimeState()
-    }
-  }, [loadRuntimeState, provider])
-
-  const selectHouse = useCallback((house: GovernanceHouse) => {
-    setState((previous) => ({
-      ...previous,
-      selectedHouse: house,
-      stakeAmountLabel: formatStakeAmount(previous.minimumStakeAmounts[house]),
-    }))
-  }, [])
-
-  const register = useCallback(
-    async (profileDraft: GovernanceProfileDraft) => {
-      if (!account || !addresses.houses) return
-      const walletClient = createGovernanceWalletClient({ provider, account })
-      if (!walletClient) return
-
-      setState((previous) => ({
-        ...previous,
-        onboardingStepId: 'stake',
-        profileDraft,
-        transactionSteps: createTransactionSteps('wallet_confirmation'),
-        error: null,
-      }))
-
-      try {
-        const selectedHouse = state.selectedHouse
-        const hash = await registerWithTransferAndCall({
-          publicClient,
-          walletClient,
-          account,
-          addresses: { ...addresses, houses: addresses.houses },
-          selectedHouse,
-          profileDraft,
-          stakeAmountWei: state.minimumStakeAmounts[selectedHouse],
-          onStage: (stage, hash) => setState((previous) => ({ ...previous, ...transactionStageToStep(stage, hash) })),
-        })
-
-        setState((previous) => ({
-          ...previous,
-          registrationHash: hash,
-          transactionSteps: createTransactionSteps('confirmed'),
-          onboardingStepId: 'success',
-        }))
-        await loadRuntimeState()
-      } catch (err: unknown) {
-        setState((previous) => ({
-          ...previous,
-          status: 'onboarding_required',
-          error: friendlyGovernanceError(err),
-          transactionSteps: createTransactionSteps('failed', friendlyGovernanceError(err)),
-        }))
-      }
-    },
-    [account, addresses, loadRuntimeState, provider, publicClient, state.minimumStakeAmounts, state.selectedHouse],
+  const publicClient = useMemo(
+    () => createGovernancePublicClient(celoRpcUrl),
+    [celoRpcUrl],
+  )
+  const addresses = useMemo(
+    () => resolveGovernanceAddresses(addressOverrides),
+    [addressOverrides],
+  )
+  const account = useMemo(
+    () => address ? getAddress(address.toLowerCase()) : null,
+    [address],
+  )
+  const resolvedChainId = chainId ?? null
+  const runtimeEnabled = Boolean(
+    account && resolvedChainId === CELO_CHAIN_ID && addresses.houses,
   )
 
-  const restake = useCallback(async () => {
-    if (!account || !addresses.houses) return
-    const walletClient = createGovernanceWalletClient({ provider, account })
-    if (!walletClient) return
-    const house = state.member?.house ?? state.selectedHouse
-
-    try {
-      const hash = await restakeWithTransferAndCall({
-        publicClient,
-        walletClient,
-        account,
-        addresses: { ...addresses, houses: addresses.houses },
-        stakeAmountWei: state.minimumStakeAmounts[house],
-        onStage: (stage, hash) => setState((previous) => ({ ...previous, ...transactionStageToStep(stage, hash) })),
-      })
-      setState((previous) => ({ ...previous, registrationHash: hash, error: null }))
-      await loadRuntimeState()
-    } catch (err: unknown) {
-      setState((previous) => ({
-        ...previous,
-        status: 'restake_required',
-        error: friendlyGovernanceError(err),
-        transactionSteps: createTransactionSteps('failed', friendlyGovernanceError(err)),
-      }))
-    }
-  }, [account, addresses, loadRuntimeState, provider, publicClient, state.member?.house, state.minimumStakeAmounts, state.selectedHouse])
-
-  const openVote = useCallback(() => {
-    setState((previous) => ({ ...previous, status: 'vote_detail' }))
-  }, [])
-
-  const closeVote = useCallback(() => {
-    setState((previous) => ({
-      ...previous,
-      status: previous.member ? statusFromMember(previous.member) : 'disconnected',
-    }))
-  }, [])
-
-  const setVoteAllocation = useCallback((recipientId: string, basisPoints: number) => {
-    setState((previous) => {
-      const allocationsBps = {
-        ...previous.dashboard.alignmentVoting.allocationsBps,
-        [recipientId]: Math.max(0, Math.min(10000, basisPoints)),
-      }
-      const allocationTotalBps = Object.values(allocationsBps).reduce((total, amount) => total + amount, 0)
-      return {
-        ...previous,
-        dashboard: {
-          ...previous.dashboard,
-          alignmentVoting: {
-            ...previous.dashboard.alignmentVoting,
-            allocationsBps,
-            allocationTotalBps,
-            disabledReason: allocationTotalBps === 10000 ? previous.dashboard.alignmentVoting.disabledReason : 'Allocation totals must equal exactly 10,000 basis points.',
-          },
-        },
-      }
-    })
-  }, [])
-
-  const submitVote = useCallback(async () => {
-    const vote = state.dashboard.alignmentVoting
-    if (!account || !addresses.houses || vote.allocationTotalBps !== 10000) return
-    const walletClient = createGovernanceWalletClient({ provider, account })
-    if (!walletClient) return
-
-    try {
-      const recipients = vote.options
-        .map((option) => option.id)
-        .filter((recipient): recipient is Address => isAddress(recipient))
-        .map((recipient) => getAddress(recipient))
-      const allocations = recipients.map((recipient) => BigInt(vote.allocationsBps[recipient] ?? 0))
-      await castGovernanceVote({
-        publicClient,
-        walletClient,
-        account,
-        housesAddress: addresses.houses,
-        recipients,
-        allocationsBps: allocations,
-      })
-      setState((previous) => ({
-        ...previous,
-        dashboard: {
-          ...previous.dashboard,
-          alignmentVoting: { ...previous.dashboard.alignmentVoting, hasVoted: true, canVote: false, disabledReason: 'You already voted in this allocation cycle.' },
-        },
-      }))
-      await loadRuntimeState()
-    } catch (err: unknown) {
-      setState((previous) => ({ ...previous, status: 'friendly_error', error: friendlyGovernanceError(err) }))
-    }
-  }, [account, addresses.houses, loadRuntimeState, provider, publicClient, state.dashboard.alignmentVoting])
+  const membership = useGovernanceMembership({
+    account,
+    chainId: resolvedChainId,
+    provider,
+    publicClient,
+    addresses,
+    environment,
+  })
+  const voting = useGovernanceVoting({
+    enabled: runtimeEnabled && Boolean(membership.schedule),
+    account,
+    provider,
+    publicClient,
+    addresses,
+    member: membership.member,
+    identityRoot: membership.identityRoot,
+    activeAlignment: membership.activeAlignment,
+    schedule: membership.schedule,
+    minimumStakes: membership.minimumStakes,
+  })
+  const funding = useGovernanceFunding({
+    enabled: runtimeEnabled,
+    publicClient,
+    housesAddress: addresses.houses,
+    tokenAddress: addresses.gToken,
+  })
 
-  const startIdentityVerification = useCallback(async () => {
-    if (!account) return
-    const walletClient = createGovernanceWalletClient({ provider, account })
-    if (!walletClient) return
+  const refresh = useCallback(async () => {
+    await Promise.all([
+      membership.refresh(),
+      voting.refresh(),
+      funding.refresh(),
+    ])
+  }, [funding, membership, voting])
 
-    const identitySdk = createGovernanceIdentitySdk({
-      publicClient,
-      walletClient,
-      environment,
-    })
-    const returnUrl = typeof window !== 'undefined' ? window.location.href : undefined
-    const identityVerificationUrl = await createGovernanceIdentityVerificationLink({
-      identitySdk,
-      returnUrl,
-      chainId: chainId ?? undefined,
-    })
-    setState((previous) => ({ ...previous, identityVerificationUrl }))
-    if (typeof window !== 'undefined') {
-      window.open(identityVerificationUrl, '_blank', 'noopener,noreferrer')
-    }
-  }, [account, chainId, environment, provider, publicClient])
+  const switchToCelo = useCallback(async () => {
+    await requestCeloMainnetSwitch(provider)
+  }, [provider])
+
+  let status: GovernanceWidgetStatus
+  let runtimeError: string | null = null
+  if (!account) {
+    status = 'disconnected'
+  } else if (resolvedChainId !== CELO_CHAIN_ID) {
+    status = 'unsupported_chain'
+  } else if (!addresses.houses) {
+    status = 'friendly_error'
+    runtimeError = 'Governance contract address is not configured yet.'
+  } else if (membership.isLoading && !membership.membership) {
+    status = 'loading'
+  } else if (membership.loadError) {
+    status = 'friendly_error'
+    runtimeError = membership.loadError
+  } else {
+    status = isActiveStatus(membership.status) && voting.isDetailOpen
+      ? 'vote_detail'
+      : membership.status
+  }
 
-  const actions = useMemo<GovernanceWidgetAdapterActions>(
-    () => ({
-      connect,
-      switchToCelo,
-      refresh: loadRuntimeState,
-      retry: loadRuntimeState,
-      selectHouse,
-      register,
-      restake,
-      openVote,
-      closeVote,
-      setVoteAllocation,
-      submitVote,
-      startIdentityVerification,
-    }),
-    [
-      closeVote,
-      connect,
-      loadRuntimeState,
-      openVote,
-      register,
-      restake,
-      selectHouse,
-      setVoteAllocation,
-      startIdentityVerification,
-      submitVote,
-      switchToCelo,
-    ],
+  const transaction = selectGovernanceTransaction(
+    membership.transaction,
+    voting.transaction,
+    voting.isDetailOpen,
   )
 
-  const resolvedState = useMemo(
-    () => ({
-      ...state,
-      address: account,
-      chainId: chainId ?? null,
-      dashboard: {
-        ...state.dashboard,
-        impact: {
-          ...state.dashboard.impact,
-          ctaLabel: 'View Impact Report Q3',
-        },
-      },
+  const state = useMemo<GovernanceWidgetAdapterState>(() => ({
+    status,
+    address: account,
+    chainId: resolvedChainId,
+    identityStatus: membership.identityStatus,
+    identityVerificationUrl: membership.identityVerificationUrl,
+    member: membership.member,
+    dashboard: createDashboardState({
+      activeMemberCount:
+        membership.activeCitizens.length + membership.activeAlignment.length,
+      voting: voting.voting,
+      funding: funding.funding,
     }),
-    [account, chainId, state],
-  )
-
-  return { state: resolvedState, actions }
+    selectedHouse: membership.selectedHouse,
+    onboardingStepId: membership.onboardingStepId,
+    profileDraft: membership.profileDraft,
+    stakeAmountLabel: membership.stakeAmountLabel,
+    minimumStakeAmounts: membership.minimumStakes,
+    transactionSteps: membership.transactionSteps,
+    registrationHash: membership.transaction.kind === 'registration'
+      ? membership.transaction.hash
+      : null,
+    transaction,
+    unstakeAvailability: membership.unstakeAvailability,
+    lifecycleNotice: membership.lifecycleNotice,
+    error: runtimeError ?? transaction.error ?? membership.error ?? voting.error,
+  }), [
+    account,
+    funding.funding,
+    membership.activeAlignment.length,
+    membership.activeCitizens.length,
+    membership.identityStatus,
+    membership.identityVerificationUrl,
+    membership.lifecycleNotice,
+    membership.error,
+    membership.member,
+    membership.minimumStakes,
+    membership.onboardingStepId,
+    membership.profileDraft,
+    membership.selectedHouse,
+    membership.stakeAmountLabel,
+    membership.transaction,
+    membership.transactionSteps,
+    membership.unstakeAvailability,
+    resolvedChainId,
+    runtimeError,
+    status,
+    transaction,
+    voting.error,
+    voting.voting,
+  ])
+
+  const actions = useMemo<GovernanceWidgetAdapterActions>(() => ({
+    connect,
+    switchToCelo,
+    refresh,
+    retry: refresh,
+    selectHouse: membership.selectHouse,
+    register: membership.register,
+    unstake: membership.unstake,
+    openVote: voting.openVote,
+    closeVote: voting.closeVote,
+    setVoteAllocation: voting.setVoteAllocation,
+    submitVote: voting.submitVote,
+    startIdentityVerification: membership.startIdentityVerification,
+  }), [
+    connect,
+    membership.register,
+    membership.selectHouse,
+    membership.startIdentityVerification,
+    membership.unstake,
+    refresh,
+    switchToCelo,
+    voting.closeVote,
+    voting.openVote,
+    voting.setVoteAllocation,
+    voting.submitVote,
+  ])
+
+  return { state, actions }
 }
 
-export { createDashboardState, createInitialState, friendlyGovernanceError, isActiveStatus }
+export {
+  createDashboardState,
+  createInitialState,
+  friendlyGovernanceError,
+  isActiveStatus,
+}
diff --git a/packages/governance-widget/src/hooks/useGovernanceFunding.ts b/packages/governance-widget/src/hooks/useGovernanceFunding.ts
new file mode 100644
index 00000000..758f679c
--- /dev/null
+++ b/packages/governance-widget/src/hooks/useGovernanceFunding.ts
@@ -0,0 +1,127 @@
+import { useCallback, useEffect, useState } from 'react'
+import type { Address, PublicClient } from 'viem'
+import type { GovernanceDashboardState } from '../widgetRuntimeContract'
+import { ZERO_ADDRESS } from '../sdks/contracts'
+import { readFlowSplitterConfig } from '../sdks/contractReads'
+import { fetchFundingReceivedSoFar } from '../sdks/funding'
+
+type FundingState = GovernanceDashboardState['fundingDistribution']
+
+export function createFundingLoadingState(): FundingState {
+  return {
+    title: 'Funding received so far',
+    centerLabel: 'Loading funding',
+    totalAmount: {
+      value: '0',
+      token: 'G$',
+      isStreaming: false,
+      streamLabel: 'Loading Superfluid streams',
+    },
+    projects: [],
+    isStreaming: false,
+    stateLabel: 'Refreshing cumulative funding…',
+    emptyStateLabel: 'Loading funding streams…',
+  }
+}
+
+export function createFundingUnavailableState(): FundingState {
+  return {
+    title: 'Funding received so far',
+    centerLabel: 'Funding unavailable',
+    totalAmount: {
+      value: '0',
+      token: 'G$',
+      isStreaming: false,
+      streamLabel: 'Superfluid stream data unavailable',
+    },
+    projects: [],
+    isStreaming: false,
+    stateLabel: 'Funding data is temporarily unavailable.',
+    emptyStateLabel: 'Membership and voting remain available while funding data refreshes.',
+  }
+}
+
+export function useGovernanceFunding(params: {
+  enabled: boolean
+  publicClient: PublicClient
+  housesAddress?: Address
+  tokenAddress: Address
+}) {
+  const { enabled, publicClient, housesAddress, tokenAddress } = params
+  const [funding, setFunding] = useState<FundingState>(() => createFundingLoadingState())
+  const [error, setError] = useState<string | null>(null)
+
+  const refresh = useCallback(async () => {
+    if (!enabled || !housesAddress) return
+    try {
+      const flowConfig = await readFlowSplitterConfig({ publicClient, housesAddress })
+      if (flowConfig.poolAddress.toLowerCase() === ZERO_ADDRESS) {
+        setFunding({
+          title: 'Funding received so far',
+          centerLabel: 'No receiver configured',
+          totalAmount: {
+            value: '0',
+            token: 'G$',
+            isStreaming: false,
+            streamLabel: 'No FlowSplitter pool receiver yet',
+          },
+          projects: [],
+          isStreaming: false,
+          emptyStateLabel: 'No funding receiver has been configured yet.',
+        })
+        setError(null)
+        return
+      }
+
+      const total = await fetchFundingReceivedSoFar({
+        receiver: flowConfig.poolAddress,
+        token: tokenAddress,
+      })
+      const hasActiveStreams = total.activeStreamCount > 0
+      const hasHistoricalStreams = total.streamCount > 0
+      setFunding({
+        title: 'Funding received so far',
+        centerLabel: hasActiveStreams
+          ? 'Active Superfluid total'
+          : hasHistoricalStreams
+            ? 'Cumulative received'
+            : 'No streams yet',
+        totalAmount: {
+          value: total.formattedAmount,
+          token: 'G$',
+          isStreaming: hasActiveStreams,
+          streamLabel: hasActiveStreams
+            ? `${total.activeStreamCount} active stream${total.activeStreamCount === 1 ? '' : 's'}`
+            : hasHistoricalStreams
+              ? `${total.streamCount} stopped historical stream${total.streamCount === 1 ? '' : 's'}`
+              : 'No inbound streams found',
+        },
+        projects: [],
+        isStreaming: hasActiveStreams,
+        stateLabel: hasHistoricalStreams && !hasActiveStreams
+          ? 'Historical streams are stopped; their received totals remain included.'
+          : undefined,
+        emptyStateLabel: hasHistoricalStreams
+          ? 'Distribution breakdown is unavailable until outgoing stream data exists.'
+          : 'No funding streams have been received yet.',
+      })
+      setError(null)
+    } catch (err: unknown) {
+      setFunding(createFundingUnavailableState())
+      setError(err instanceof Error ? err.message : 'Funding refresh failed')
+    }
+  }, [enabled, housesAddress, publicClient, tokenAddress])
+
+  useEffect(() => {
+    if (!enabled) {
+      setFunding(createFundingLoadingState())
+      setError(null)
+      return
+    }
+    void refresh()
+    const interval = globalThis.setInterval(() => void refresh(), 30_000)
+    return () => globalThis.clearInterval(interval)
+  }, [enabled, refresh])
+
+  return { funding, error, refresh }
+}
diff --git a/packages/governance-widget/src/hooks/useGovernanceMembership.ts b/packages/governance-widget/src/hooks/useGovernanceMembership.ts
new file mode 100644
index 00000000..a9a73dc2
--- /dev/null
+++ b/packages/governance-widget/src/hooks/useGovernanceMembership.ts
@@ -0,0 +1,542 @@
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
+import { Linking } from 'react-native'
+import type { EIP1193Provider } from '@goodwidget/core'
+import type { StepperStepItem } from '@goodwidget/ui'
+import type { Address, Hex, PublicClient } from 'viem'
+import type { GovernanceHouse, GovernanceOnboardingStepId, GovernanceProfileDraft } from '../types'
+import type {
+  GovernanceTransactionState,
+  GovernanceTransactionStatus,
+  GovernanceUnstakeAvailability,
+  GovernanceWidgetStatus,
+} from '../widgetRuntimeContract'
+import {
+  CELO_CHAIN_ID,
+  createGovernanceWalletClient,
+  formatStakeAmount,
+  safeMillisecondsFromSeconds,
+  type GovernanceContractAddresses,
+  type GovernanceMemberRecord,
+} from '../sdks/contracts'
+import {
+  readGovernanceMembership,
+  readGovernanceSchedule,
+  type GovernanceMembershipReads,
+  type GovernanceSchedule,
+  type GovernanceStakeRequirements,
+} from '../sdks/contractReads'
+import {
+  registerWithTransferAndCall,
+  unstakeGovernanceMembership,
+  type GovernanceTransactionStage,
+} from '../sdks/transactions'
+import {
+  createGovernanceIdentitySdk,
+  createGovernanceIdentityVerificationLink,
+  type GovernanceIdentityEnvironment,
+} from '../sdks/identity'
+import { useGovernanceTransactionGuard } from './useGovernanceTransactionGuard'
+
+const EMPTY_STAKES: GovernanceStakeRequirements = {
+  citizenship: 0n,
+  alignment: 0n,
+}
+
+const EMPTY_ADDRESSES: Address[] = []
+
+const IDLE_TRANSACTION: GovernanceTransactionState = {
+  kind: null,
+  status: 'idle',
+  hash: null,
+  error: null,
+}
+
+export function createTransactionSteps(
+  stage: GovernanceTransactionStatus,
+  failedMessage?: string,
+): StepperStepItem[] {
+  const rejected = stage === 'rejected'
+  const reverted = stage === 'reverted' || stage === 'failed'
+
+  return [
+    {
+      id: 'prepare',
+      title: 'Prepare wallet balance',
+      description: 'Keep the required G$ amount available before the membership transaction starts.',
+      status: stage === 'idle' ? 'active' : 'completed',
+    },
+    {
+      id: 'approve',
+      title: 'Confirm in wallet',
+      description: rejected ? failedMessage : 'Approve the membership transaction from your wallet.',
+      status: rejected ? 'failed' : stage === 'wallet_confirmation' ? 'active' : stage === 'idle' ? 'pending' : 'completed',
+    },
+    {
+      id: 'stake',
+      title: 'Transaction submitted',
+      description: reverted ? failedMessage : 'Wait for the Celo transaction receipt before continuing.',
+      status: reverted ? 'failed' : stage === 'submitted' ? 'active' : stage === 'confirmed' ? 'completed' : 'pending',
+    },
+    {
+      id: 'finalize',
+      title: 'Confirmed on-chain',
+      status: stage === 'confirmed' ? 'completed' : 'pending',
+    },
+  ]
+}
+
+export function friendlyGovernanceError(err: unknown): string {
+  if (!(err instanceof Error)) return 'Something went wrong. Please try again.'
+
+  const message = err.message
+  if (message.includes('User rejected') || message.includes('4001')) {
+    return 'Transaction rejected in the wallet.'
+  }
+  if (message.includes('Already voted')) return 'You already voted in this allocation cycle.'
+  if (message.includes('Alloc != 10000')) return 'Allocation totals must equal exactly 10,000 basis points.'
+  if (message.includes('insufficient funds')) {
+    return 'Your wallet does not have enough funds for this governance action.'
+  }
+  if (message.includes('Term not passed')) {
+    return 'Your membership is still locked for the current governance term.'
+  }
+  if (message.includes('revert') || message.includes('reverted')) {
+    return 'The governance contract rejected this action. Review your details and try again.'
+  }
+  if (message.includes('fetch') || message.includes('network') || message.includes('HTTP')) {
+    return 'Unable to reach Celo Mainnet. Check your connection and try again.'
+  }
+  return 'Unable to complete the governance action. Please try again.'
+}
+
+export function transactionStatusFromError(err: unknown): Extract<GovernanceTransactionStatus, 'rejected' | 'reverted' | 'failed'> {
+  if (err instanceof Error && (err.message.includes('User rejected') || err.message.includes('4001'))) {
+    return 'rejected'
+  }
+  if (err instanceof Error && (err.message.includes('revert') || err.message.includes('reverted'))) {
+    return 'reverted'
+  }
+  return 'failed'
+}
+
+export function statusFromMember(member: GovernanceMemberRecord | null): GovernanceWidgetStatus {
+  if (!member || member.status === 'none' || member.status === 'unstaked') return 'onboarding_required'
+  // GoodDaoHouses activates Citizen registrations immediately; Pending is Alignment-only.
+  if (member.status === 'pending' && member.house === 'alignment') return 'pending_alignment'
+  if (member.status === 'active' && member.house === 'alignment') return 'active_alignment'
+  if (member.status === 'active') return 'active_citizenship'
+  if (member.status === 'revoked') return 'revoked'
+  return 'onboarding_required'
+}
+
+export function isActiveStatus(status: GovernanceWidgetStatus): boolean {
+  return status === 'active_alignment' || status === 'active_citizenship'
+}
+
+export function getUnstakeAvailability(
+  member: GovernanceMemberRecord | null,
+  termDurationSeconds: bigint,
+  currentBlockTime: number | null,
+): GovernanceUnstakeAvailability {
+  if (!member || member.status !== 'active') {
+    return { canUnstake: false, unlockAt: null, disabledReason: 'Only active members can unstake.' }
+  }
+  if (!member.updatedAt || termDurationSeconds <= 0n) {
+    return {
+      canUnstake: false,
+      unlockAt: null,
+      disabledReason: 'The membership lock period is unavailable. Refresh before trying again.',
+    }
+  }
+  if (currentBlockTime === null) {
+    return {
+      canUnstake: false,
+      unlockAt: null,
+      disabledReason: 'The current Celo block time is unavailable. Refresh before trying again.',
+    }
+  }
+
+  const termDurationMs = safeMillisecondsFromSeconds(termDurationSeconds)
+  if (termDurationMs === null) {
+    return {
+      canUnstake: false,
+      unlockAt: null,
+      disabledReason: 'The membership lock period is unavailable. Refresh before trying again.',
+    }
+  }
+
+  const unlockAt = member.updatedAt + termDurationMs
+  if (!Number.isSafeInteger(unlockAt)) {
+    return {
+      canUnstake: false,
+      unlockAt: null,
+      disabledReason: 'The membership lock period is unavailable. Refresh before trying again.',
+    }
+  }
+  return currentBlockTime >= unlockAt
+    ? { canUnstake: true, unlockAt }
+    : {
+        canUnstake: false,
+        unlockAt,
+        disabledReason: 'Membership remains locked until the current governance term has passed.',
+      }
+}
+
+interface MembershipHookState {
+  loadedAccount: Address | null
+  membership: GovernanceMembershipReads | null
+  schedule: GovernanceSchedule | null
+  selectedHouse: GovernanceHouse
+  onboardingStepId?: GovernanceOnboardingStepId
+  profileDraft: GovernanceProfileDraft
+  transactionSteps: StepperStepItem[]
+  transaction: GovernanceTransactionState
+  identityVerificationUrl: string | null
+  lifecycleNotice: string | null
+  isLoading: boolean
+  loadError: string | null
+  error: string | null
+}
+
+export function resolveRegistrationStake(
+  membership: GovernanceMembershipReads | null,
+  selectedHouse: GovernanceHouse,
+): { stakeAmountWei: bigint; error: null } | { stakeAmountWei: null; error: string } {
+  if (!membership) {
+    return {
+      stakeAmountWei: null,
+      error: 'Membership data is still loading. Please try again in a moment.',
+    }
+  }
+  return { stakeAmountWei: membership.minimumStakes[selectedHouse], error: null }
+}
+
+function createInitialMembershipState(): MembershipHookState {
+  return {
+    loadedAccount: null,
+    membership: null,
+    schedule: null,
+    selectedHouse: 'citizenship',
+    onboardingStepId: undefined,
+    profileDraft: {},
+    transactionSteps: createTransactionSteps('idle'),
+    transaction: IDLE_TRANSACTION,
+    identityVerificationUrl: null,
+    lifecycleNotice: null,
+    isLoading: false,
+    loadError: null,
+    error: null,
+  }
+}
+
+function transactionFromStage(
+  kind: GovernanceTransactionState['kind'],
+  stage: GovernanceTransactionStage,
+  hash?: Hex,
+): GovernanceTransactionState {
+  return { kind, status: stage, hash: hash ?? null, error: null }
+}
+
+export function useGovernanceMembership(params: {
+  account: Address | null
+  chainId: number | null
+  provider: EIP1193Provider | null
+  publicClient: PublicClient
+  addresses: GovernanceContractAddresses
+  environment: GovernanceIdentityEnvironment
+}) {
+  const { account, chainId, provider, publicClient, addresses, environment } = params
+  const [state, setState] = useState<MembershipHookState>(() => createInitialMembershipState())
+  const refreshRequestId = useRef(0)
+  const transactionGuard = useGovernanceTransactionGuard([
+    account?.toLowerCase() ?? 'no-account',
+    chainId ?? 'no-chain',
+    addresses.houses?.toLowerCase() ?? 'no-contract',
+  ].join(':'))
+  const enabled = Boolean(account && chainId === CELO_CHAIN_ID && addresses.houses)
+  const hasCurrentAccountState = Boolean(
+    account && state.loadedAccount?.toLowerCase() === account.toLowerCase(),
+  )
+  const membership = hasCurrentAccountState ? state.membership : null
+  const schedule = hasCurrentAccountState ? state.schedule : null
+
+  const refresh = useCallback(async () => {
+    if (!account || !addresses.houses || chainId !== CELO_CHAIN_ID) return
+    const requestId = ++refreshRequestId.current
+    setState((previous) => ({ ...previous, isLoading: true, loadError: null }))
+
+    try {
+      const [membership, schedule] = await Promise.all([
+        readGovernanceMembership({
+          publicClient,
+          housesAddress: addresses.houses,
+          goodIdAddress: addresses.goodId,
+          account,
+        }),
+        readGovernanceSchedule({ publicClient, housesAddress: addresses.houses }),
+      ])
+      setState((previous) => requestId === refreshRequestId.current
+        ? {
+            ...previous,
+            loadedAccount: account,
+            membership,
+            schedule,
+            selectedHouse:
+              membership.member.status === 'none' || membership.member.status === 'unstaked'
+                ? previous.selectedHouse
+                : membership.member.house,
+            isLoading: false,
+            loadError: null,
+          }
+        : previous)
+    } catch (err: unknown) {
+      setState((previous) => requestId === refreshRequestId.current
+        ? {
+            ...previous,
+            loadedAccount: account,
+            isLoading: false,
+            loadError: friendlyGovernanceError(err),
+          }
+        : previous)
+    }
+  }, [account, addresses.goodId, addresses.houses, chainId, publicClient])
+
+  useEffect(() => {
+    refreshRequestId.current += 1
+    if (!enabled) {
+      setState(createInitialMembershipState())
+      return
+    }
+    setState(createInitialMembershipState())
+    void refresh()
+  }, [enabled, refresh])
+
+  useEffect(() => {
+    if (!enabled) return undefined
+    const interval = globalThis.setInterval(() => void refresh(), 30_000)
+    return () => globalThis.clearInterval(interval)
+  }, [enabled, refresh])
+
+  const selectHouse = useCallback((house: GovernanceHouse) => {
+    setState((previous) => ({ ...previous, selectedHouse: house }))
+  }, [])
+
+  const register = useCallback(async (profileDraft: GovernanceProfileDraft) => {
+    if (!account || !addresses.houses) return
+    const selectedHouse = state.selectedHouse
+    const registrationStake = resolveRegistrationStake(membership, selectedHouse)
+    if (registrationStake.stakeAmountWei === null) {
+      setState((previous) => ({
+        ...previous,
+        error: registrationStake.error,
+      }))
+      return
+    }
+    const transactionToken = transactionGuard.begin()
+    if (!transactionToken) return
+
+    const walletClient = createGovernanceWalletClient({ provider, account })
+    if (!walletClient) {
+      const error = 'The connected wallet provider is unavailable.'
+      if (transactionGuard.isCurrent(transactionToken)) {
+        setState((previous) => ({
+          ...previous,
+          onboardingStepId: 'stake',
+          profileDraft,
+          transactionSteps: createTransactionSteps('failed', error),
+          transaction: { kind: 'registration', status: 'failed', hash: null, error },
+          error,
+        }))
+      }
+      transactionGuard.finish(transactionToken)
+      return
+    }
+
+    const stakeAmountWei = registrationStake.stakeAmountWei
+    setState((previous) => ({
+      ...previous,
+      onboardingStepId: 'stake',
+      profileDraft,
+      transactionSteps: createTransactionSteps('wallet_confirmation'),
+      transaction: transactionFromStage('registration', 'wallet_confirmation'),
+      lifecycleNotice: null,
+      error: null,
+    }))
+
+    try {
+      const hash = await registerWithTransferAndCall({
+        publicClient,
+        walletClient,
+        account,
+        addresses: { ...addresses, houses: addresses.houses },
+        selectedHouse,
+        profileDraft,
+        stakeAmountWei,
+        onStage: (stage, stageHash) => {
+          if (!transactionGuard.isCurrent(transactionToken)) return
+          setState((previous) => ({
+            ...previous,
+            transaction: transactionFromStage('registration', stage, stageHash),
+            transactionSteps: createTransactionSteps(stage),
+          }))
+        },
+      })
+      if (!transactionGuard.isCurrent(transactionToken)) return
+      setState((previous) => ({
+        ...previous,
+        transaction: { kind: 'registration', status: 'confirmed', hash, error: null },
+        transactionSteps: createTransactionSteps('confirmed'),
+        onboardingStepId: 'success',
+      }))
+      await refresh()
+    } catch (err: unknown) {
+      if (!transactionGuard.isCurrent(transactionToken)) return
+      const status = transactionStatusFromError(err)
+      const error = friendlyGovernanceError(err)
+      setState((previous) => ({
+        ...previous,
+        transaction: { kind: 'registration', status, hash: previous.transaction.hash, error },
+        transactionSteps: createTransactionSteps(status, error),
+        error,
+      }))
+    } finally {
+      transactionGuard.finish(transactionToken)
+    }
+  }, [account, addresses, membership, provider, publicClient, refresh, state.selectedHouse, transactionGuard])
+
+  const unstake = useCallback(async () => {
+    if (!account || !addresses.houses) return
+    const availability = getUnstakeAvailability(
+      membership?.member ?? null,
+      schedule?.termDurationSeconds ?? 0n,
+      schedule?.currentBlockTime ?? null,
+    )
+    if (!availability.canUnstake) return
+    const transactionToken = transactionGuard.begin()
+    if (!transactionToken) return
+
+    const walletClient = createGovernanceWalletClient({ provider, account })
+    if (!walletClient) {
+      const error = 'The connected wallet provider is unavailable.'
+      if (transactionGuard.isCurrent(transactionToken)) {
+        setState((previous) => ({
+          ...previous,
+          transaction: { kind: 'unstake', status: 'failed', hash: null, error },
+          error,
+        }))
+      }
+      transactionGuard.finish(transactionToken)
+      return
+    }
+
+    setState((previous) => ({
+      ...previous,
+      transaction: transactionFromStage('unstake', 'wallet_confirmation'),
+      lifecycleNotice: null,
+      error: null,
+    }))
+
+    try {
+      const hash = await unstakeGovernanceMembership({
+        publicClient,
+        walletClient,
+        account,
+        housesAddress: addresses.houses,
+        onStage: (stage, stageHash) => {
+          if (!transactionGuard.isCurrent(transactionToken)) return
+          setState((previous) => ({
+            ...previous,
+            transaction: transactionFromStage('unstake', stage, stageHash),
+          }))
+        },
+      })
+      if (!transactionGuard.isCurrent(transactionToken)) return
+      setState((previous) => ({
+        ...previous,
+        transaction: { kind: 'unstake', status: 'confirmed', hash, error: null },
+        lifecycleNotice: 'Membership unstaked successfully. You can now join a governance house again.',
+      }))
+      await refresh()
+    } catch (err: unknown) {
+      if (!transactionGuard.isCurrent(transactionToken)) return
+      const status = transactionStatusFromError(err)
+      const error = friendlyGovernanceError(err)
+      setState((previous) => ({
+        ...previous,
+        transaction: { kind: 'unstake', status, hash: previous.transaction.hash, error },
+        error,
+      }))
+    } finally {
+      transactionGuard.finish(transactionToken)
+    }
+  }, [
+    account,
+    addresses.houses,
+    membership?.member,
+    provider,
+    publicClient,
+    refresh,
+    schedule?.currentBlockTime,
+    schedule?.termDurationSeconds,
+    transactionGuard,
+  ])
+
+  const startIdentityVerification = useCallback(async () => {
+    if (!account) return
+    const walletClient = createGovernanceWalletClient({ provider, account })
+    if (!walletClient) {
+      setState((previous) => ({ ...previous, error: 'The connected wallet provider is unavailable.' }))
+      return
+    }
+
+    try {
+      setState((previous) => ({ ...previous, error: null }))
+      const identitySdk = createGovernanceIdentitySdk({ publicClient, walletClient, environment })
+      const returnUrl = (await Linking.getInitialURL()) ?? undefined
+      const identityVerificationUrl = await createGovernanceIdentityVerificationLink({
+        identitySdk,
+        returnUrl,
+        chainId: chainId ?? undefined,
+      })
+      setState((previous) => ({ ...previous, identityVerificationUrl }))
+      await Linking.openURL(identityVerificationUrl)
+    } catch (err: unknown) {
+      setState((previous) => ({ ...previous, error: friendlyGovernanceError(err) }))
+    }
+  }, [account, chainId, environment, provider, publicClient])
+
+  const minimumStakes = membership?.minimumStakes ?? EMPTY_STAKES
+  const member = membership?.member ?? null
+  const status = statusFromMember(member)
+  const unstakeAvailability = useMemo(
+    () => getUnstakeAvailability(
+      member,
+      schedule?.termDurationSeconds ?? 0n,
+      schedule?.currentBlockTime ?? null,
+    ),
+    [member, schedule?.currentBlockTime, schedule?.termDurationSeconds],
+  )
+
+  return {
+    ...state,
+    membership,
+    schedule,
+    isLoading: enabled && !hasCurrentAccountState ? true : state.isLoading,
+    status,
+    member,
+    minimumStakes,
+    stakeAmountLabel: formatStakeAmount(minimumStakes[state.selectedHouse]),
+    identityRoot: membership?.identityRoot ?? null,
+    identityStatus: membership?.identityRoot && membership.identityRoot !== '0x0000000000000000000000000000000000000000'
+      ? 'verified' as const
+      : 'unverified' as const,
+    activeCitizens: membership?.activeCitizens ?? EMPTY_ADDRESSES,
+    activeAlignment: membership?.activeAlignment ?? EMPTY_ADDRESSES,
+    unstakeAvailability,
+    refresh,
+    selectHouse,
+    register,
+    unstake,
+    startIdentityVerification,
+  }
+}
diff --git a/packages/governance-widget/src/hooks/useGovernanceTransactionGuard.ts b/packages/governance-widget/src/hooks/useGovernanceTransactionGuard.ts
new file mode 100644
index 00000000..3d8e8156
--- /dev/null
+++ b/packages/governance-widget/src/hooks/useGovernanceTransactionGuard.ts
@@ -0,0 +1,44 @@
+import { useCallback, useEffect, useMemo, useRef } from 'react'
+
+export interface GovernanceTransactionToken {
+  id: number
+  scope: string
+}
+
+/**
+ * Keeps one wallet transaction active per account/chain/contract scope.
+ * A scope change invalidates callbacks from the previous wallet before they
+ * can publish receipt state into the newly connected account.
+ */
+export function useGovernanceTransactionGuard(scope: string) {
+  const scopeRef = useRef(scope)
+  const nextIdRef = useRef(0)
+  const activeIdRef = useRef<number | null>(null)
+  scopeRef.current = scope
+
+  useEffect(() => {
+    nextIdRef.current += 1
+    activeIdRef.current = null
+  }, [scope])
+
+  const begin = useCallback((): GovernanceTransactionToken | null => {
+    if (activeIdRef.current !== null) return null
+
+    const id = ++nextIdRef.current
+    activeIdRef.current = id
+    return { id, scope: scopeRef.current }
+  }, [])
+
+  const isCurrent = useCallback((token: GovernanceTransactionToken): boolean => (
+    token.id === activeIdRef.current && token.scope === scopeRef.current
+  ), [])
+
+  const finish = useCallback((token: GovernanceTransactionToken): void => {
+    if (isCurrent(token)) activeIdRef.current = null
+  }, [isCurrent])
+
+  return useMemo(
+    () => ({ begin, isCurrent, finish }),
+    [begin, finish, isCurrent],
+  )
+}
diff --git a/packages/governance-widget/src/hooks/useGovernanceVoting.ts b/packages/governance-widget/src/hooks/useGovernanceVoting.ts
new file mode 100644
index 00000000..fdebfc63
--- /dev/null
+++ b/packages/governance-widget/src/hooks/useGovernanceVoting.ts
@@ -0,0 +1,382 @@
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
+import type { EIP1193Provider } from '@goodwidget/core'
+import { getAddress, isAddress, type Address, type PublicClient } from 'viem'
+import type { RankedVotingOption } from '../types'
+import {
+  getGovernanceVotingDisabledReason,
+  type GovernanceTransactionState,
+  type GovernanceVotingState,
+} from '../widgetRuntimeContract'
+import {
+  ZERO_ADDRESS,
+  createGovernanceWalletClient,
+  safeMillisecondsFromSeconds,
+  type GovernanceContractAddresses,
+  type GovernanceMemberRecord,
+} from '../sdks/contracts'
+import {
+  readGovernanceVote,
+  type GovernanceSchedule,
+  type GovernanceStakeRequirements,
+} from '../sdks/contractReads'
+import { castGovernanceVote } from '../sdks/transactions'
+import { friendlyGovernanceError, transactionStatusFromError } from './useGovernanceMembership'
+import { useGovernanceTransactionGuard } from './useGovernanceTransactionGuard'
+
+const IDLE_VOTE_TRANSACTION: GovernanceTransactionState = {
+  kind: null,
+  status: 'idle',
+  hash: null,
+  error: null,
+}
+
+function shortAddress(address: Address): string {
+  return `${address.slice(0, 6)}…${address.slice(-4)}`
+}
+
+function nextVotingWindowLabel(schedule: GovernanceSchedule): string {
+  if (!schedule.cycleStartTime || schedule.termDurationSeconds === 0n || schedule.currentBlockTime === null) {
+    return 'Contract schedule unavailable'
+  }
+  const termMs = safeMillisecondsFromSeconds(schedule.termDurationSeconds)
+  if (termMs === null) return 'Contract schedule unavailable'
+  const nowMs = schedule.currentBlockTime
+  const nextStart = nowMs < schedule.cycleStartTime
+    ? schedule.cycleStartTime
+    : schedule.cycleStartTime + (Math.floor((nowMs - schedule.cycleStartTime) / termMs) + 1) * termMs
+  if (!Number.isSafeInteger(nextStart)) return 'Contract schedule unavailable'
+  return `Next window starts ${new Intl.DateTimeFormat('en-US', {
+    month: 'short',
+    day: 'numeric',
+    year: 'numeric',
+  }).format(new Date(nextStart))}`
+}
+
+export function resolveGovernanceVoterKey(
+  member: GovernanceMemberRecord | null,
+  identityRoot: Address | null,
+  account: Address,
+): Address {
+  return member?.house === 'citizenship' && identityRoot && identityRoot.toLowerCase() !== ZERO_ADDRESS
+    ? identityRoot
+    : account
+}
+
+export function createVotingState(params: {
+  member: GovernanceMemberRecord | null
+  identityRoot: Address | null
+  voteId: bigint
+  isVotingOpen: boolean
+  voteStartTime: number | null
+  voteConfig: { startTime: number | null; endTime: number | null; executedAt: number | null; executed: boolean }
+  recipients: Address[]
+  hasVoted: boolean
+  finalizedUnits: Record<string, bigint>
+  schedule: GovernanceSchedule
+  minimumStake: bigint
+}): GovernanceVotingState {
+  const recipients = params.recipients.map((recipient) => getAddress(recipient))
+  const totalUnits = Object.values(params.finalizedUnits).reduce((total, amount) => total + amount, 0n)
+  const options: RankedVotingOption[] = recipients.map((recipient) => {
+    const units = params.finalizedUnits[recipient.toLowerCase()] ?? params.finalizedUnits[recipient] ?? 0n
+    return {
+      id: recipient,
+      label: shortAddress(recipient),
+      percentage: totalUnits > 0n ? Number((units * 100n) / totalUnits) : 0,
+    }
+  })
+  const allocationsBps = Object.fromEntries(options.map((option) => [option.id, 0]))
+  const isActiveMember = params.member?.status === 'active'
+  const hasRequiredStake = Boolean(
+    params.member && params.member.stakedAmount >= params.minimumStake,
+  )
+  const hasCitizenIdentity = params.member?.house !== 'citizenship' || Boolean(
+    params.identityRoot && params.identityRoot.toLowerCase() !== ZERO_ADDRESS,
+  )
+  const joinedBeforeVote = Boolean(
+    params.member?.joinedAt &&
+    params.voteStartTime &&
+    params.member.joinedAt <= params.voteStartTime,
+  )
+  const canVote = Boolean(
+    isActiveMember &&
+    hasRequiredStake &&
+    hasCitizenIdentity &&
+    joinedBeforeVote &&
+    params.isVotingOpen &&
+    !params.hasVoted &&
+    recipients.length > 0,
+  )
+
+  let title = 'Alignment vote'
+  let summaryLabel = 'Allocate 10,000 bps to eligible House of Alignment recipients'
+  let disabledReason: string | undefined
+
+  if (!params.isVotingOpen) {
+    title = 'Upcoming Alignment vote'
+    summaryLabel = nextVotingWindowLabel(params.schedule)
+    disabledReason = 'Voting is currently closed.'
+  } else if (recipients.length === 0) {
+    disabledReason = 'No House of Alignment members were eligible when this vote opened.'
+  } else if (params.hasVoted) {
+    disabledReason = 'You already voted in this allocation cycle.'
+  } else if (!isActiveMember) {
+    disabledReason = 'Only active members can vote.'
+  } else if (!hasRequiredStake) {
+    disabledReason = 'Your membership stake is below the current minimum required for this house.'
+  } else if (!joinedBeforeVote) {
+    disabledReason = 'Members who joined after this vote opened cannot participate in this cycle.'
+  } else if (!hasCitizenIdentity) {
+    disabledReason = 'Verify your GoodID before voting as a Citizen.'
+  }
+
+  if (params.voteConfig.executed) {
+    title = 'Executed Alignment vote'
+    summaryLabel = 'Final units executed'
+    disabledReason = 'This vote has already been executed.'
+  }
+
+  return {
+    voteId: params.voteId.toString(),
+    title,
+    summaryLabel,
+    options,
+    recipients,
+    allocationsBps,
+    allocationTotalBps: 0,
+    canVote,
+    hasVoted: params.hasVoted,
+    isVotingOpen: params.isVotingOpen,
+    executed: params.voteConfig.executed,
+    finalizedUnits: Object.fromEntries(
+      Object.entries(params.finalizedUnits).map(([recipient, units]) => [recipient, units.toString()]),
+    ),
+    disabledReason,
+  }
+}
+
+export function validateGovernanceBallot(
+  recipients: string[],
+  allocationsBps: Record<string, number>,
+): { recipients: Address[]; allocations: bigint[] } {
+  if (recipients.length === 0) throw new Error('No recipients')
+  if (!recipients.every((recipient) => isAddress(recipient))) throw new Error('Invalid recipient')
+
+  const normalized = recipients.map((recipient) => getAddress(recipient))
+  if (new Set(normalized.map((recipient) => recipient.toLowerCase())).size !== normalized.length) {
+    throw new Error('Duplicate recipient')
+  }
+  const allocations = normalized.map((recipient, index) => {
+    const originalRecipient = recipients[index]
+    const amount = allocationsBps[recipient]
+      ?? allocationsBps[originalRecipient]
+      ?? allocationsBps[recipient.toLowerCase()]
+      ?? 0
+    if (!Number.isSafeInteger(amount)) throw new Error('Invalid allocation')
+    return BigInt(amount)
+  })
+  const total = allocations.reduce((sum, allocation) => sum + allocation, 0n)
+  if (allocations.some((allocation) => allocation < 0n || allocation > 10_000n)) {
+    throw new Error('Invalid allocation')
+  }
+  if (total !== 10_000n) throw new Error('Alloc != 10000')
+  return { recipients: normalized, allocations }
+}
+
+export function createEmptyVotingState(): GovernanceVotingState {
+  return {
+    voteId: '0',
+    title: 'Upcoming Alignment vote',
+    summaryLabel: 'Contract schedule unavailable',
+    options: [],
+    recipients: [],
+    allocationsBps: {},
+    allocationTotalBps: 0,
+    canVote: false,
+    hasVoted: false,
+    isVotingOpen: false,
+    executed: false,
+    finalizedUnits: {},
+    disabledReason: 'Connect a wallet to load governance voting state.',
+  }
+}
+
+export function useGovernanceVoting(params: {
+  enabled: boolean
+  account: Address | null
+  provider: EIP1193Provider | null
+  publicClient: PublicClient
+  addresses: GovernanceContractAddresses
+  member: GovernanceMemberRecord | null
+  identityRoot: Address | null
+  activeAlignment: Address[]
+  schedule: GovernanceSchedule | null
+  minimumStakes: GovernanceStakeRequirements
+}) {
+  const {
+    enabled,
+    account,
+    provider,
+    publicClient,
+    addresses,
+    member,
+    identityRoot,
+    activeAlignment,
+    schedule,
+    minimumStakes,
+  } = params
+  const [voting, setVoting] = useState<GovernanceVotingState>(() => createEmptyVotingState())
+  const [transaction, setTransaction] = useState<GovernanceTransactionState>(IDLE_VOTE_TRANSACTION)
+  const [isDetailOpen, setIsDetailOpen] = useState(false)
+  const [error, setError] = useState<string | null>(null)
+  const refreshRequestId = useRef(0)
+  const transactionGuard = useGovernanceTransactionGuard([
+    account?.toLowerCase() ?? 'no-account',
+    addresses.houses?.toLowerCase() ?? 'no-contract',
+    enabled ? 'enabled' : 'disabled',
+  ].join(':'))
+
+  const refresh = useCallback(async () => {
+    if (!enabled || !account || !addresses.houses || !schedule) return
+    const requestId = ++refreshRequestId.current
+    try {
+      const voterKey = resolveGovernanceVoterKey(member, identityRoot, account)
+      const vote = await readGovernanceVote({
+        publicClient,
+        housesAddress: addresses.houses,
+        voterKey,
+        activeAlignment,
+        schedule,
+      })
+      if (requestId === refreshRequestId.current) {
+        setVoting(createVotingState({
+          member,
+          identityRoot,
+          voteId: vote.voteId,
+          isVotingOpen: vote.isVotingPeriod,
+          voteStartTime: vote.voteStartTime,
+          voteConfig: vote.voteConfig,
+          recipients: vote.recipients,
+          hasVoted: vote.hasVoted,
+          finalizedUnits: vote.finalizedUnits,
+          schedule,
+          minimumStake: member ? minimumStakes[member.house] : 0n,
+        }))
+        setError(null)
+      }
+    } catch (err: unknown) {
+      if (requestId === refreshRequestId.current) setError(friendlyGovernanceError(err))
+    }
+  }, [
+    account,
+    activeAlignment,
+    addresses.houses,
+    enabled,
+    identityRoot,
+    member,
+    minimumStakes,
+    publicClient,
+    schedule,
+  ])
+
+  useEffect(() => {
+    refreshRequestId.current += 1
+    setVoting(createEmptyVotingState())
+    setTransaction(IDLE_VOTE_TRANSACTION)
+    setIsDetailOpen(false)
+    setError(null)
+  }, [account, addresses.houses, enabled])
+
+  useEffect(() => {
+    // Membership's 30-second refresh updates these dependencies,
+    // keeping voting on the same cadence.
+    if (enabled) void refresh()
+  }, [enabled, refresh])
+
+  const setVoteAllocation = useCallback((recipientId: string, basisPoints: number) => {
+    setVoting((previous) => {
+      if (!(recipientId in previous.allocationsBps)) return previous
+      const normalizedBasisPoints = Number.isFinite(basisPoints)
+        ? Math.trunc(basisPoints)
+        : 0
+      const allocationsBps = {
+        ...previous.allocationsBps,
+        [recipientId]: Math.max(0, Math.min(10_000, normalizedBasisPoints)),
+      }
+      const allocationTotalBps = Object.values(allocationsBps).reduce((total, amount) => total + amount, 0)
+      return {
+        ...previous,
+        allocationsBps,
+        allocationTotalBps,
+      }
+    })
+  }, [])
+
+  const submitVote = useCallback(async () => {
+    if (!account || !addresses.houses) return
+    const disabledReason = getGovernanceVotingDisabledReason(voting)
+    if (disabledReason || !voting.canVote) {
+      const unavailableError = disabledReason ?? 'Voting is currently unavailable.'
+      setError(unavailableError)
+      return
+    }
+    const transactionToken = transactionGuard.begin()
+    if (!transactionToken) return
+
+    const walletClient = createGovernanceWalletClient({ provider, account })
+    if (!walletClient) {
+      const providerError = 'The connected wallet provider is unavailable.'
+      if (transactionGuard.isCurrent(transactionToken)) {
+        setTransaction({ kind: 'vote', status: 'failed', hash: null, error: providerError })
+        setError(providerError)
+      }
+      transactionGuard.finish(transactionToken)
+      return
+    }
+
+    try {
+      const ballot = validateGovernanceBallot(voting.recipients, voting.allocationsBps)
+      setTransaction({ kind: 'vote', status: 'wallet_confirmation', hash: null, error: null })
+      const hash = await castGovernanceVote({
+        publicClient,
+        walletClient,
+        account,
+        housesAddress: addresses.houses,
+        recipients: ballot.recipients,
+        allocationsBps: ballot.allocations,
+        onStage: (stage, stageHash) => {
+          if (!transactionGuard.isCurrent(transactionToken)) return
+          setTransaction({
+            kind: 'vote',
+            status: stage,
+            hash: stageHash ?? null,
+            error: null,
+          })
+        },
+      })
+      if (!transactionGuard.isCurrent(transactionToken)) return
+      setTransaction({ kind: 'vote', status: 'confirmed', hash, error: null })
+      await refresh()
+    } catch (err: unknown) {
+      if (!transactionGuard.isCurrent(transactionToken)) return
+      const status = transactionStatusFromError(err)
+      const friendlyError = friendlyGovernanceError(err)
+      setTransaction((previous) => ({ ...previous, kind: 'vote', status, error: friendlyError }))
+      setError(friendlyError)
+    } finally {
+      transactionGuard.finish(transactionToken)
+    }
+  }, [account, addresses.houses, provider, publicClient, refresh, transactionGuard, voting])
+
+  return useMemo(() => ({
+    voting,
+    transaction,
+    isDetailOpen,
+    error,
+    refresh,
+    openVote: () => setIsDetailOpen(true),
+    closeVote: () => setIsDetailOpen(false),
+    setVoteAllocation,
+    submitVote,
+  }), [error, isDetailOpen, refresh, setVoteAllocation, submitVote, transaction, voting])
+}
diff --git a/packages/governance-widget/src/index.ts b/packages/governance-widget/src/index.ts
index fb2a25cf..49d029b1 100644
--- a/packages/governance-widget/src/index.ts
+++ b/packages/governance-widget/src/index.ts
@@ -39,6 +39,10 @@ export { DEFAULT_TRANSACTION_STEPS } from './onboarding/constants'
 export { useGovernanceAdapter } from './adapter'
 export type {
   GovernanceDashboardState,
+  GovernanceTransactionKind,
+  GovernanceTransactionState,
+  GovernanceTransactionStatus,
+  GovernanceUnstakeAvailability,
   GovernanceVotingState,
   GovernanceWidgetAdapterActions,
   GovernanceWidgetAdapterFactory,
@@ -55,7 +59,6 @@ export {
   G_TOKEN_CELO_ADDRESS,
   encodeGovernanceRegistrationData,
   mapFlowSplitterConfig,
-  mapHoaEligibilityRecord,
   mapMemberRecord,
   mapVoteConfig,
   resolveGovernanceAddresses,
diff --git a/packages/governance-widget/src/onboarding/GovernanceOnboardingFlow.tsx b/packages/governance-widget/src/onboarding/GovernanceOnboardingFlow.tsx
index 202ffff8..25e3cbef 100644
--- a/packages/governance-widget/src/onboarding/GovernanceOnboardingFlow.tsx
+++ b/packages/governance-widget/src/onboarding/GovernanceOnboardingFlow.tsx
@@ -23,9 +23,8 @@ import type { StepperStepItem } from '@goodwidget/ui'
 interface GovernanceOnboardingFlowProps {
   identityStatus: GovernanceIdentityStatus
   walletAddress?: string
-  disabledHouseOptions: GovernanceHouse[]
   initialFieldErrors: GovernanceProfileFieldErrors
-  stakeAmountLabel: string
+  stakeAmountLabels: Record<GovernanceHouse, string>
   transactionSteps: StepperStepItem[]
   finalActions: GovernanceOnboardingAction[]
   onHouseChange?: (house: GovernanceHouse) => void
@@ -35,12 +34,15 @@ interface GovernanceOnboardingFlowProps {
   dataTestId?: string
 }
 
+function areTransactionStepsComplete(steps: StepperStepItem[]): boolean {
+  return steps.length > 0 && steps.every((step) => step.status === 'completed')
+}
+
 export function GovernanceOnboardingFlow({
   identityStatus,
   walletAddress,
-  disabledHouseOptions,
   initialFieldErrors,
-  stakeAmountLabel,
+  stakeAmountLabels,
   transactionSteps = DEFAULT_TRANSACTION_STEPS,
   finalActions = DEFAULT_FINAL_ACTIONS,
   onHouseChange,
@@ -50,8 +52,6 @@ export function GovernanceOnboardingFlow({
   dataTestId,
 }: GovernanceOnboardingFlowProps) {
   const { currentStep, steps, data, setData, next } = usePageWizard()
-  // The success step is a terminal view and should not appear in the progress
-  // indicator — Stitch design shows exactly 4 steps: Verify, Path, Profile, Transact.
   const stepperDisplaySteps = steps.filter((s) => s.id !== 'success')
   const [fieldErrors, setFieldErrors] = useState<GovernanceProfileFieldErrors>(initialFieldErrors)
 
@@ -59,6 +59,7 @@ export function GovernanceOnboardingFlow({
   const selectedHouse = wizardData.selectedHouse
   const profileDraft = wizardData.profileDraft ?? {}
   const resolvedHouse: GovernanceHouse = selectedHouse ?? 'citizenship'
+  const selectedStakeAmountLabel = stakeAmountLabels[resolvedHouse]
   const isIdentityVerified = identityStatus === 'verified'
   const profileIsComplete = isProfileDraftComplete(resolvedHouse, profileDraft)
 
@@ -74,7 +75,6 @@ export function GovernanceOnboardingFlow({
       }
     })
 
-    // Clear the error as the user types so they get immediate positive feedback
     setFieldErrors((previousErrors) => {
       const nextErrors = { ...previousErrors }
       delete nextErrors[fieldKey]
@@ -82,8 +82,6 @@ export function GovernanceOnboardingFlow({
     })
   }
 
-  // Validate a single field when the user leaves it (blur) so they see
-  // inline feedback before hitting the submit button.
   const handleFieldBlur = (fieldKey: GovernanceProfileFieldKey, fieldValue: string) => {
     const error = validateField(fieldKey, fieldValue)
     setFieldErrors((prev) => {
@@ -132,26 +130,24 @@ export function GovernanceOnboardingFlow({
           onVerifyPress={onIdentityVerificationPress}
         />
       )
-      // Footer is null — "Proceed to Membership" is inside OnboardingIdentityCard
       shellFooter = null
       break
 
     case 'house':
       shellTitle = 'Choose your house'
       shellDescription =
-        'Where will your impact be felt? Choose the path that best fits your contribution.'
+        'Select the governance body you wish to join.'
       shellContent = (
         <HouseStepContent
           selectedHouse={selectedHouse}
-          disabledHouseOptions={disabledHouseOptions}
-          stakeAmountLabel={stakeAmountLabel}
+          stakeAmountLabels={stakeAmountLabels}
           onHouseSelect={handleHouseSelect}
         />
       )
       shellFooter = (
-        <XStack gap="$3" justifyContent="flex-end" flexWrap="wrap">
-          <Button disabled={!selectedHouse} onPress={next}>
-            <ButtonText>Continue to profile</ButtonText>
+        <XStack width="100%">
+          <Button fullWidth disabled={!selectedHouse} onPress={next}>
+            <ButtonText>Continue</ButtonText>
           </Button>
         </XStack>
       )
@@ -166,37 +162,34 @@ export function GovernanceOnboardingFlow({
           selectedHouse={resolvedHouse}
           profileDraft={profileDraft}
           fieldErrors={fieldErrors}
-          stakeAmountLabel={stakeAmountLabel}
+          stakeAmountLabel={selectedStakeAmountLabel}
           onProfileFieldChange={updateProfileField}
           onProfileFieldBlur={handleFieldBlur}
           ctaDisabled={!profileIsComplete}
-          // CTA button lives inside the card — no shell footer button needed
           onContinuePress={handleProfileContinue}
         />
       )
-      // Footer is null — "Create Profile and Stake" is inside ProfileStepContent card
       shellFooter = null
       break
 
     case 'stake': {
-      // Disable the CTA until every on-chain transaction step has completed.
-      // L03TJ3 feedback: "I can continue to success while the progress is not finalized?"
-      const allStepsCompleted =
-        transactionSteps.length > 0 &&
-        transactionSteps.every((step) => step.status === 'completed')
-      shellTitle = 'Creating profile & staking'
+      const allStepsCompleted = areTransactionStepsComplete(transactionSteps)
+      shellTitle = 'Securing your membership'
       shellDescription =
-        'Please wait while your transaction is confirmed on-chain. You can review each step below.'
+        'Transactions are being processed on-chain. Please do not close this window.'
       shellContent = (
-        <StakeStepContent stakeAmountLabel={stakeAmountLabel} transactionSteps={transactionSteps} />
+        <StakeStepContent
+          stakeAmountLabel={selectedStakeAmountLabel}
+          transactionSteps={transactionSteps}
+        />
       )
-      shellFooter = (
-        <XStack gap="$3" justifyContent="flex-end" flexWrap="wrap">
-          <Button disabled={!allStepsCompleted} onPress={next}>
+      shellFooter = allStepsCompleted ? (
+        <XStack width="100%">
+          <Button fullWidth onPress={next}>
             <ButtonText>Continue to success</ButtonText>
           </Button>
         </XStack>
-      )
+      ) : null
       break
     }
 
@@ -205,7 +198,7 @@ export function GovernanceOnboardingFlow({
       shellContent = (
         <SuccessStepContent
           finalActions={finalActions}
-          stakeAmountLabel={stakeAmountLabel}
+          stakeAmountLabel={selectedStakeAmountLabel}
           onFinalActionPress={onFinalActionPress}
         />
       )
diff --git a/packages/governance-widget/src/onboarding/HouseSelectionCard.tsx b/packages/governance-widget/src/onboarding/HouseSelectionCard.tsx
index 83e36c6c..20d9746d 100644
--- a/packages/governance-widget/src/onboarding/HouseSelectionCard.tsx
+++ b/packages/governance-widget/src/onboarding/HouseSelectionCard.tsx
@@ -1,18 +1,12 @@
 import { Stack } from 'tamagui'
-import { Badge, BadgeText, Heading, Icon, PillText, Text, XStack, createComponent } from '@goodwidget/ui'
+import { Heading, Icon, PillText, XStack, createComponent } from '@goodwidget/ui'
 import { HOUSE_COPY } from './copy'
 import type { GovernanceHouse } from '../types'
 
-/** Maps each house to its Figma-specified icon name. */
 const HOUSE_ICON: Record<GovernanceHouse, string> = {
   citizenship: 'user',
   alignment: 'compass',
 }
-
-
-/**
- * Internal house-selection button. Uses createComponent to register for theme overrides.
- */
 const HouseOptionButton = createComponent(Stack, {
   name: 'GovernanceHouseOptionButton',
   tag: 'button',
@@ -41,13 +35,6 @@ const HouseOptionButton = createComponent(Stack, {
         backgroundColor: '$backgroundHover',
       },
     },
-    disabled: {
-      true: {
-        opacity: 0.5,
-        cursor: 'not-allowed',
-        pointerEvents: 'none',
-      },
-    },
   } as const,
 })
 
@@ -100,7 +87,6 @@ const HousePill = createComponent(Stack, {
 interface HouseSelectionCardProps {
   house: GovernanceHouse
   isSelected: boolean
-  isDisabled: boolean
   stakeAmountLabel: string
   onPress: () => void
 }
@@ -108,7 +94,6 @@ interface HouseSelectionCardProps {
 export function HouseSelectionCard({
   house,
   isSelected,
-  isDisabled,
   stakeAmountLabel,
   onPress,
 }: HouseSelectionCardProps) {
@@ -117,24 +102,19 @@ export function HouseSelectionCard({
   return (
     <HouseOptionButton
       selected={isSelected}
-      disabled={isDisabled}
       role="radio"
       aria-checked={isSelected}
       onPress={onPress}
       data-testid={`GovernanceOnboardingWidget-house-${house}`}
     >
-      {/* ── Header: icon + title + radio (matches Figma layout) ── */}
       <XStack alignItems="center" gap="$3" width="100%">
         <Icon name={HOUSE_ICON[house]} size="sm" color="primary" />
-        <Heading level={5} flex={1}>{houseCopy.title}</Heading>
+        <Heading level={6} flex={1}>{houseCopy.title}</Heading>
         <RadioBullet selected={isSelected}>
           <RadioDot selected={isSelected} />
         </RadioBullet>
       </XStack>
 
-      {/* ── Summary text ─────────────────────────────────────────── */}
-      <Text tone="secondary">{houseCopy.summary}</Text>
-
       <XStack gap="$2" flexWrap="wrap" alignItems="center">
         <HousePill>
           <PillText>{houseCopy.label}</PillText>
@@ -142,14 +122,7 @@ export function HouseSelectionCard({
         <HousePill>
           <PillText>{`${stakeAmountLabel} stake`}</PillText>
         </HousePill>
-        {isSelected ? (
-          <Badge type="success">
-            <BadgeText>Selected</BadgeText>
-          </Badge>
-        ) : null}
       </XStack>
-
-      {/* "Continue with this house" row removed — not in Figma design */}
     </HouseOptionButton>
   )
 }
diff --git a/packages/governance-widget/src/onboarding/OnboardingIdentityCard.tsx b/packages/governance-widget/src/onboarding/OnboardingIdentityCard.tsx
index 0430b601..45ef3893 100644
--- a/packages/governance-widget/src/onboarding/OnboardingIdentityCard.tsx
+++ b/packages/governance-widget/src/onboarding/OnboardingIdentityCard.tsx
@@ -124,7 +124,6 @@ export function OnboardingIdentityCard({
           </AccentRow>
         </YStack>
 
-        {/* ── CTA button ─────────────────────────────────────────── */}
         {isVerified ? (
           <Button
             fullWidth
diff --git a/packages/governance-widget/src/onboarding/copy.ts b/packages/governance-widget/src/onboarding/copy.ts
index bdee8c22..64988ccf 100644
--- a/packages/governance-widget/src/onboarding/copy.ts
+++ b/packages/governance-widget/src/onboarding/copy.ts
@@ -13,14 +13,14 @@ export const HOUSE_COPY: Record<GovernanceHouse, HouseCopy> = {
     title: 'House of Citizenship',
     summary: 'Represent verified community members and highlight your public governance identity.',
     helper: 'Collect the profile details that describe the member behind the wallet.',
-    label: 'Membership house',
+    label: 'Identity',
     defaultStakeAmount: '100 G$',
   },
   alignment: {
     title: 'House of Alignment',
     summary: 'Coordinate aligned projects and explain how your mission creates value for the network.',
     helper: 'Collect project-facing metadata that can later map to the onchain registration shape.',
-    label: 'Project house',
+    label: 'Protocol security',
     defaultStakeAmount: '250 G$',
   },
 }
diff --git a/packages/governance-widget/src/onboarding/steps/HouseStepContent.tsx b/packages/governance-widget/src/onboarding/steps/HouseStepContent.tsx
index 0571c074..583d2fad 100644
--- a/packages/governance-widget/src/onboarding/steps/HouseStepContent.tsx
+++ b/packages/governance-widget/src/onboarding/steps/HouseStepContent.tsx
@@ -4,35 +4,31 @@ import type { GovernanceHouse } from '../../types'
 
 interface HouseStepContentProps {
   selectedHouse?: GovernanceHouse
-  disabledHouseOptions: GovernanceHouse[]
-  stakeAmountLabel: string
+  stakeAmountLabels: Record<GovernanceHouse, string>
   onHouseSelect: (nextHouse: GovernanceHouse) => void
 }
 
 export function HouseStepContent({
   selectedHouse,
-  disabledHouseOptions,
-  stakeAmountLabel,
+  stakeAmountLabels,
   onHouseSelect,
 }: HouseStepContentProps) {
   return (
     <YStack gap="$3">
       <Card elevated>
         <YStack gap="$3" role="radiogroup" aria-label="Select your governance house">
-          <HouseSelectionCard
-            house="citizenship"
-            isSelected={selectedHouse === 'citizenship'}
-            isDisabled={disabledHouseOptions.includes('citizenship')}
-            stakeAmountLabel={stakeAmountLabel}
-            onPress={() => onHouseSelect('citizenship')}
-          />
           <HouseSelectionCard
             house="alignment"
             isSelected={selectedHouse === 'alignment'}
-            isDisabled={disabledHouseOptions.includes('alignment')}
-            stakeAmountLabel={stakeAmountLabel}
+            stakeAmountLabel={stakeAmountLabels.alignment}
             onPress={() => onHouseSelect('alignment')}
           />
+          <HouseSelectionCard
+            house="citizenship"
+            isSelected={selectedHouse === 'citizenship'}
+            stakeAmountLabel={stakeAmountLabels.citizenship}
+            onPress={() => onHouseSelect('citizenship')}
+          />
         </YStack>
       </Card>
     </YStack>
diff --git a/packages/governance-widget/src/onboarding/steps/ProfileStepContent.tsx b/packages/governance-widget/src/onboarding/steps/ProfileStepContent.tsx
index fe74fca3..ef3df1ee 100644
--- a/packages/governance-widget/src/onboarding/steps/ProfileStepContent.tsx
+++ b/packages/governance-widget/src/onboarding/steps/ProfileStepContent.tsx
@@ -183,7 +183,6 @@ export function ProfileStepContent({
             )}
           </YStack>
 
-          {/* ── CTA button (Figma: inside card at bottom) ───────────────── */}
           <Button
             fullWidth
             disabled={ctaDisabled}
diff --git a/packages/governance-widget/src/onboarding/steps/StakeStepContent.tsx b/packages/governance-widget/src/onboarding/steps/StakeStepContent.tsx
index b26590e5..01df20ae 100644
--- a/packages/governance-widget/src/onboarding/steps/StakeStepContent.tsx
+++ b/packages/governance-widget/src/onboarding/steps/StakeStepContent.tsx
@@ -1,4 +1,4 @@
-import { Badge, BadgeText, Card, Heading, Stepper, Text, XStack, YStack } from '@goodwidget/ui'
+import { Badge, BadgeText, Card, Stepper, Text, XStack, YStack } from '@goodwidget/ui'
 import { resolveStakeSummary } from '../resolveStakeSummary'
 import type { StepperStepItem } from '@goodwidget/ui'
 
@@ -22,20 +22,14 @@ export function StakeStepContent({ stakeAmountLabel, transactionSteps }: StakeSt
     <YStack gap="$3">
       <Card elevated>
         <YStack gap="$3">
-          <YStack gap="$2">
-            <XStack alignItems="flex-start" justifyContent="space-between" gap="$2" flexWrap="wrap">
-              <YStack gap="$1" flex={1} minWidth={0}>
-                <Text variant="caption" tone="secondary">
-                  {`${stakeAmountLabel} locked stake`}
-                </Text>
-                {/* level 5 avoids overflow on narrow mobile cards */}
-                <Heading level={5}>{`Creating profile & staking`}</Heading>
-              </YStack>
-              <Badge type={stakeSummary.badgeType}>
-                <BadgeText>{stakeSummary.title}</BadgeText>
-              </Badge>
-            </XStack>
-          </YStack>
+          <XStack alignItems="center" justifyContent="space-between" gap="$2" flexWrap="wrap">
+            <Text variant="caption" tone="secondary">
+              {`${stakeAmountLabel} locked stake`}
+            </Text>
+            <Badge type={stakeSummary.badgeType}>
+              <BadgeText>{stakeSummary.title}</BadgeText>
+            </Badge>
+          </XStack>
 
           <XStack alignItems="center" gap="$3">
             <YStack flex={1} height={8} borderRadius="$full" backgroundColor="$borderColor" overflow="hidden">
diff --git a/packages/governance-widget/src/sdks/contractReads.ts b/packages/governance-widget/src/sdks/contractReads.ts
index 826227a2..4426cdf4 100644
--- a/packages/governance-widget/src/sdks/contractReads.ts
+++ b/packages/governance-widget/src/sdks/contractReads.ts
@@ -5,12 +5,11 @@ import {
   formatStakeAmount,
   houseToContractValue,
   mapFlowSplitterConfig,
-  mapHoaEligibilityRecord,
   mapMemberRecord,
   mapVoteConfig,
   readGoodIdRoot,
+  safeMillisecondsFromSeconds,
   type GovernanceFlowSplitterConfig,
-  type GovernanceHoaEligibilityRecord,
   type GovernanceMemberRecord,
   type GovernanceVoteConfig,
 } from './contracts'
@@ -24,12 +23,29 @@ export interface GovernanceSchedule {
   cycleStartTime: number | null
   termDurationSeconds: bigint
   votingTermLengthSeconds: bigint
+  currentBlockTime: number | null
+}
+
+export function voteStartTimeFromSchedule(
+  schedule: GovernanceSchedule,
+  voteId: bigint,
+): number | null {
+  if (!schedule.cycleStartTime || schedule.termDurationSeconds <= 0n) return null
+  // GoodDaoHouses._getCurrentVoteWindow derives voteId as elapsed / termDuration,
+  // so vote 0 starts exactly at cycleStartTime.
+  if (voteId < 0n) return null
+  const voteOffsetSeconds = voteId * schedule.termDurationSeconds
+  const voteOffsetMs = voteOffsetSeconds === 0n
+    ? 0
+    : safeMillisecondsFromSeconds(voteOffsetSeconds)
+  if (voteOffsetMs === null) return null
+  const voteStartTime = schedule.cycleStartTime + voteOffsetMs
+  return Number.isSafeInteger(voteStartTime) ? voteStartTime : null
 }
 
 export interface GovernanceMembershipReads {
   member: GovernanceMemberRecord
   minimumStakes: GovernanceStakeRequirements
-  hoaEligibility: GovernanceHoaEligibilityRecord
   identityRoot: Address
   activeCitizens: Address[]
   activeAlignment: Address[]
@@ -42,7 +58,7 @@ export async function readGovernanceMembership(params: {
   account: Address
 }): Promise<GovernanceMembershipReads> {
   const { publicClient, housesAddress, goodIdAddress, account } = params
-  const [member, citizenshipStake, alignmentStake, hoaEligibility, identityRoot, activeCitizens, activeAlignment] =
+  const [member, citizenshipStake, alignmentStake, identityRoot, activeCitizens, activeAlignment] =
     await Promise.all([
       publicClient.readContract({
         address: housesAddress,
@@ -62,12 +78,6 @@ export async function readGovernanceMembership(params: {
         functionName: 'minimumStake',
         args: [houseToContractValue('alignment')],
       }),
-      publicClient.readContract({
-        address: housesAddress,
-        abi: GOODDAO_HOUSES_ABI,
-        functionName: 'getHoaEligibility',
-        args: [account],
-      }),
       readGoodIdRoot(publicClient, goodIdAddress, account),
       publicClient.readContract({
         address: housesAddress,
@@ -89,10 +99,9 @@ export async function readGovernanceMembership(params: {
       citizenship: citizenshipStake,
       alignment: alignmentStake,
     },
-    hoaEligibility: mapHoaEligibilityRecord(hoaEligibility),
     identityRoot,
-    activeCitizens,
-    activeAlignment,
+    activeCitizens: [...activeCitizens],
+    activeAlignment: [...activeAlignment],
   }
 }
 
@@ -101,7 +110,7 @@ export async function readGovernanceSchedule(params: {
   housesAddress: Address
 }): Promise<GovernanceSchedule> {
   const { publicClient, housesAddress } = params
-  const [cycleStartTime, termDuration, votingTermLength] = await Promise.all([
+  const [cycleStartTime, termDuration, votingTermLength, currentBlockTime] = await Promise.all([
     publicClient.readContract({
       address: housesAddress,
       abi: GOODDAO_HOUSES_ABI,
@@ -117,12 +126,16 @@ export async function readGovernanceSchedule(params: {
       abi: GOODDAO_HOUSES_ABI,
       functionName: 'votingTermLength',
     }),
+    publicClient.getBlock({ blockTag: 'latest' })
+      .then((block) => safeMillisecondsFromSeconds(block.timestamp))
+      .catch(() => null),
   ])
 
   return {
-    cycleStartTime: cycleStartTime > 0n ? Number(cycleStartTime) * 1000 : null,
+    cycleStartTime: safeMillisecondsFromSeconds(cycleStartTime),
     termDurationSeconds: termDuration,
     votingTermLengthSeconds: votingTermLength,
+    currentBlockTime,
   }
 }
 
@@ -131,6 +144,7 @@ export async function readGovernanceVote(params: {
   housesAddress: Address
   voterKey: Address
   activeAlignment: Address[]
+  schedule: GovernanceSchedule
 }): Promise<{
   isVotingPeriod: boolean
   voteId: bigint
@@ -138,8 +152,9 @@ export async function readGovernanceVote(params: {
   recipients: Address[]
   hasVoted: boolean
   finalizedUnits: Record<Address, bigint>
+  voteStartTime: number | null
 }> {
-  const { publicClient, housesAddress, voterKey, activeAlignment } = params
+  const { publicClient, housesAddress, voterKey, activeAlignment, schedule } = params
   const [isVotingPeriod, voteId] = await Promise.all([
     publicClient.readContract({ address: housesAddress, abi: GOODDAO_HOUSES_ABI, functionName: 'isVotingPeriod' }),
     publicClient.readContract({ address: housesAddress, abi: GOODDAO_HOUSES_ABI, functionName: 'getCurrentVoteId' }),
@@ -167,7 +182,34 @@ export async function readGovernanceVote(params: {
   ])
 
   const voteConfig = mapVoteConfig(rawVoteConfig)
-  const recipients = rawRecipients.length > 0 ? rawRecipients : isVotingPeriod ? activeAlignment : rawRecipients
+  const voteStartTime = voteConfig.startTime ?? voteStartTimeFromSchedule(schedule, voteId)
+  let recipients: Address[] = [...rawRecipients]
+
+  if (rawRecipients.length === 0 && isVotingPeriod && voteStartTime) {
+    // Before the first ballot creates the on-chain snapshot, mirror the
+    // contract rule so late-joining HoA members are never submitted.
+    const provisionalRecords = await Promise.all(
+      activeAlignment.map(async (recipient) => ({
+        recipient,
+        member: mapMemberRecord(
+          await publicClient.readContract({
+            address: housesAddress,
+            abi: GOODDAO_HOUSES_ABI,
+            functionName: 'getMember',
+            args: [recipient],
+          }),
+        ),
+      })),
+    )
+    recipients = provisionalRecords
+      .filter(({ member }) =>
+        member.status === 'active' &&
+        member.house === 'alignment' &&
+        member.joinedAt !== null &&
+        member.joinedAt <= voteStartTime,
+      )
+      .map(({ recipient }) => recipient)
+  }
   const finalizedEntries = await Promise.all(
     recipients.map(async (recipient) => {
       const units = await publicClient.readContract({
@@ -187,6 +229,7 @@ export async function readGovernanceVote(params: {
     recipients,
     hasVoted,
     finalizedUnits: Object.fromEntries(finalizedEntries) as Record<Address, bigint>,
+    voteStartTime,
   }
 }
 
diff --git a/packages/governance-widget/src/sdks/contracts.ts b/packages/governance-widget/src/sdks/contracts.ts
index 6af432e8..b7bc4517 100644
--- a/packages/governance-widget/src/sdks/contracts.ts
+++ b/packages/governance-widget/src/sdks/contracts.ts
@@ -37,7 +37,6 @@ export const CELO_CHAIN: Chain = {
 export const GOODDAO_HOUSES_ABI = parseAbi([
   'function minimumStake(uint8 house) view returns (uint256)',
   'function getMember(address account) view returns ((uint8 house, uint8 status, uint256 stakedAmount, uint64 joinedAt, uint64 updatedAt, uint64 unstakedAt, uint256 memberIndex, string name, string socialLinks, string projectWebpage, string missionStatement, string distributionStrategy))',
-  'function getHoaEligibility(address account) view returns ((bool isEligible, uint64 listedAt, uint64 updatedAt, uint64 delistedAt))',
   'function getActiveMembers(uint8 house) view returns (address[])',
   'function getActiveMembers(uint8 house, uint256 startIndex, uint256 endIndex) view returns (address[])',
   'function cycleStartTime() view returns (uint64)',
@@ -51,6 +50,7 @@ export const GOODDAO_HOUSES_ABI = parseAbi([
   'function getFinalizedUnits(uint256 voteId, address recipient) view returns (uint128)',
   'function flowSplitterConfig() view returns (address splitter, uint256 poolId, address poolAddress)',
   'function castVote(address[] recipients, uint256[] allocations)',
+  'function unstake()',
 ])
 
 export const G_TOKEN_ABI = parseAbi([
@@ -93,13 +93,6 @@ export interface GovernanceFlowSplitterConfig {
   poolAddress: Address
 }
 
-export interface GovernanceHoaEligibilityRecord {
-  isEligible: boolean
-  listedAt: number | null
-  updatedAt: number | null
-  delistedAt: number | null
-}
-
 export interface GovernanceContractAddresses {
   houses?: Address
   gToken: Address
@@ -214,8 +207,10 @@ export function encodeGovernanceRegistrationData(
   )
 }
 
-function timestampFromSeconds(value: bigint): number | null {
-  return value > 0n ? Number(value) * 1000 : null
+export function safeMillisecondsFromSeconds(value: bigint): number | null {
+  if (value <= 0n) return null
+  const milliseconds = Number(value * 1000n)
+  return Number.isSafeInteger(milliseconds) ? milliseconds : null
 }
 
 function tupleValue(rawValue: unknown, index: number, key: string): unknown {
@@ -231,9 +226,9 @@ export function mapMemberRecord(rawMember: readonly unknown[] | Record<string, u
     house: CONTRACT_TO_HOUSE[houseValue] ?? 'citizenship',
     status: CONTRACT_TO_STATUS[statusValue] ?? 'none',
     stakedAmount: BigInt(String(tupleValue(rawMember, 2, 'stakedAmount') ?? 0)),
-    joinedAt: timestampFromSeconds(BigInt(String(tupleValue(rawMember, 3, 'joinedAt') ?? 0))),
-    updatedAt: timestampFromSeconds(BigInt(String(tupleValue(rawMember, 4, 'updatedAt') ?? 0))),
-    unstakedAt: timestampFromSeconds(BigInt(String(tupleValue(rawMember, 5, 'unstakedAt') ?? 0))),
+    joinedAt: safeMillisecondsFromSeconds(BigInt(String(tupleValue(rawMember, 3, 'joinedAt') ?? 0))),
+    updatedAt: safeMillisecondsFromSeconds(BigInt(String(tupleValue(rawMember, 4, 'updatedAt') ?? 0))),
+    unstakedAt: safeMillisecondsFromSeconds(BigInt(String(tupleValue(rawMember, 5, 'unstakedAt') ?? 0))),
     memberIndex: BigInt(String(tupleValue(rawMember, 6, 'memberIndex') ?? 0)),
     name: String(tupleValue(rawMember, 7, 'name') ?? ''),
     socialLinks: String(tupleValue(rawMember, 8, 'socialLinks') ?? ''),
@@ -245,9 +240,9 @@ export function mapMemberRecord(rawMember: readonly unknown[] | Record<string, u
 
 export function mapVoteConfig(rawConfig: readonly unknown[] | Record<string, unknown>): GovernanceVoteConfig {
   return {
-    startTime: timestampFromSeconds(BigInt(String(tupleValue(rawConfig, 0, 'startTime') ?? 0))),
-    endTime: timestampFromSeconds(BigInt(String(tupleValue(rawConfig, 1, 'endTime') ?? 0))),
-    executedAt: timestampFromSeconds(BigInt(String(tupleValue(rawConfig, 2, 'executedAt') ?? 0))),
+    startTime: safeMillisecondsFromSeconds(BigInt(String(tupleValue(rawConfig, 0, 'startTime') ?? 0))),
+    endTime: safeMillisecondsFromSeconds(BigInt(String(tupleValue(rawConfig, 1, 'endTime') ?? 0))),
+    executedAt: safeMillisecondsFromSeconds(BigInt(String(tupleValue(rawConfig, 2, 'executedAt') ?? 0))),
     executed: Boolean(tupleValue(rawConfig, 3, 'executed')),
   }
 }
@@ -260,15 +255,6 @@ export function mapFlowSplitterConfig(rawConfig: readonly unknown[] | Record<str
   }
 }
 
-export function mapHoaEligibilityRecord(rawRecord: readonly unknown[] | Record<string, unknown>): GovernanceHoaEligibilityRecord {
-  return {
-    isEligible: Boolean(tupleValue(rawRecord, 0, 'isEligible')),
-    listedAt: timestampFromSeconds(BigInt(String(tupleValue(rawRecord, 1, 'listedAt') ?? 0))),
-    updatedAt: timestampFromSeconds(BigInt(String(tupleValue(rawRecord, 2, 'updatedAt') ?? 0))),
-    delistedAt: timestampFromSeconds(BigInt(String(tupleValue(rawRecord, 3, 'delistedAt') ?? 0))),
-  }
-}
-
 export function formatStakeAmount(amountWei: bigint): string {
   return `${formatUnits(amountWei, 18)} G$`
 }
diff --git a/packages/governance-widget/src/sdks/funding.ts b/packages/governance-widget/src/sdks/funding.ts
index ff63c9fd..68c24c0b 100644
--- a/packages/governance-widget/src/sdks/funding.ts
+++ b/packages/governance-widget/src/sdks/funding.ts
@@ -1,4 +1,4 @@
-import { formatUnits, getAddress, type Address } from 'viem'
+import { getAddress, type Address } from 'viem'
 
 export const SUPERFLUID_CELO_SUBGRAPH_URL = 'https://subgraph-endpoints.superfluid.dev/celo-mainnet/protocol-v1'
 export const FUNDING_STREAMS_QUERY = `query FundingStreams($receiver: String!, $token: String!, $first: Int!, $skip: Int!) {
@@ -25,6 +25,7 @@ export interface FundingTotalResult {
   amountWei: bigint
   formattedAmount: string
   streamCount: number
+  activeStreamCount: number
 }
 
 interface FundingStreamsResponse {
@@ -32,6 +33,23 @@ interface FundingStreamsResponse {
   errors?: Array<{ message?: string }>
 }
 
+export function formatFundingAmountWei(amountWei: bigint, maximumFractionDigits = 3): string {
+  const decimals = 18
+  const requestedPrecision = Number.isFinite(maximumFractionDigits)
+    ? Math.trunc(maximumFractionDigits)
+    : 3
+  const precision = Math.max(0, Math.min(decimals, requestedPrecision))
+  const fractionalScale = 10n ** BigInt(precision)
+  const roundingDivisor = 10n ** BigInt(decimals - precision)
+  const rounded = (amountWei + roundingDivisor / 2n) / roundingDivisor
+  const whole = rounded / fractionalScale
+  const fraction = (rounded % fractionalScale)
+    .toString()
+    .padStart(precision, '0')
+    .replace(/0+$/, '')
+  return fraction ? `${whole}.${fraction}` : whole.toString()
+}
+
 export function calculateStreamAmountWei(stream: FundingStreamRecord, nowSeconds: bigint): bigint {
   const streamedUntilUpdatedAt = BigInt(stream.streamedUntilUpdatedAt)
   const currentFlowRate = BigInt(stream.currentFlowRate)
@@ -55,6 +73,7 @@ export async function fetchFundingReceivedSoFar(params: {
   const first = 1000
   let skip = 0
   let total = 0n
+  let activeStreamCount = 0
   for (;;) {
     const response = await fetcher(endpoint, {
       method: 'POST',
@@ -77,13 +96,17 @@ export async function fetchFundingReceivedSoFar(params: {
     const streams = json.data?.streams ?? []
     for (const stream of streams) {
       total += calculateStreamAmountWei(stream, nowSeconds)
+      if (BigInt(stream.currentFlowRate) !== 0n) {
+        activeStreamCount += 1
+      }
     }
 
     if (streams.length < first) {
       return {
         amountWei: total,
-        formattedAmount: formatUnits(total, 18),
+        formattedAmount: formatFundingAmountWei(total),
         streamCount: skip + streams.length,
+        activeStreamCount,
       }
     }
 
diff --git a/packages/governance-widget/src/sdks/transactions.ts b/packages/governance-widget/src/sdks/transactions.ts
index ea122150..1d92dfa3 100644
--- a/packages/governance-widget/src/sdks/transactions.ts
+++ b/packages/governance-widget/src/sdks/transactions.ts
@@ -37,22 +37,20 @@ export async function registerWithTransferAndCall(params: {
   return hash
 }
 
-export async function restakeWithTransferAndCall(params: {
+export async function unstakeGovernanceMembership(params: {
   publicClient: PublicClient
   walletClient: WalletClient
   account: Address
-  addresses: GovernanceContractAddresses & { houses: Address }
-  stakeAmountWei: bigint
+  housesAddress: Address
   onStage?: (stage: GovernanceTransactionStage, hash?: Hex) => void
 }): Promise<Hex> {
   params.onStage?.('wallet_confirmation')
   const hash = await params.walletClient.writeContract({
     account: params.account,
     chain: CELO_CHAIN,
-    address: params.addresses.gToken,
-    abi: G_TOKEN_ABI,
-    functionName: 'transferAndCall',
-    args: [params.addresses.houses, params.stakeAmountWei, '0x'],
+    address: params.housesAddress,
+    abi: GOODDAO_HOUSES_ABI,
+    functionName: 'unstake',
   })
   params.onStage?.('submitted', hash)
   await waitForSuccessfulReceipt(params.publicClient, hash)
diff --git a/packages/governance-widget/src/types.ts b/packages/governance-widget/src/types.ts
index 52c777b6..5a2bc3e4 100644
--- a/packages/governance-widget/src/types.ts
+++ b/packages/governance-widget/src/types.ts
@@ -51,10 +51,10 @@ export interface GovernanceOnboardingWidgetProps {
    */
   walletAddress?: string
   initialHouse?: GovernanceHouse
-  disabledHouseOptions?: GovernanceHouse[]
   initialProfileDraft?: GovernanceProfileDraft
   initialFieldErrors?: GovernanceProfileFieldErrors
   stakeAmountLabel?: string
+  stakeAmountLabels?: Record<GovernanceHouse, string>
   transactionSteps?: StepperStepItem[]
   finalActions?: GovernanceOnboardingAction[]
   dataTestId?: string
diff --git a/packages/governance-widget/src/widgetRuntimeContract.ts b/packages/governance-widget/src/widgetRuntimeContract.ts
index 19b0aaae..bc720f20 100644
--- a/packages/governance-widget/src/widgetRuntimeContract.ts
+++ b/packages/governance-widget/src/widgetRuntimeContract.ts
@@ -22,10 +22,34 @@ export type GovernanceWidgetStatus =
   | 'pending_alignment'
   | 'active_citizenship'
   | 'active_alignment'
-  | 'restake_required'
+  | 'revoked'
   | 'vote_detail'
   | 'friendly_error'
 
+export type GovernanceTransactionKind = 'registration' | 'unstake' | 'vote'
+
+export type GovernanceTransactionStatus =
+  | 'idle'
+  | 'wallet_confirmation'
+  | 'submitted'
+  | 'confirmed'
+  | 'rejected'
+  | 'reverted'
+  | 'failed'
+
+export interface GovernanceTransactionState {
+  kind: GovernanceTransactionKind | null
+  status: GovernanceTransactionStatus
+  hash: Hex | null
+  error: string | null
+}
+
+export interface GovernanceUnstakeAvailability {
+  canUnstake: boolean
+  unlockAt: number | null
+  disabledReason?: string
+}
+
 export interface GovernanceVotingState {
   voteId: string
   title: string
@@ -42,6 +66,18 @@ export interface GovernanceVotingState {
   disabledReason?: string
 }
 
+export const GOVERNANCE_ALLOCATION_TOTAL_ERROR =
+  'Allocation totals must equal exactly 10,000 basis points.'
+
+export function getGovernanceVotingDisabledReason(
+  voting: GovernanceVotingState,
+): string | undefined {
+  if (voting.disabledReason) return voting.disabledReason
+  return voting.canVote && voting.allocationTotalBps !== 10_000
+    ? GOVERNANCE_ALLOCATION_TOTAL_ERROR
+    : undefined
+}
+
 export interface GovernanceDashboardState {
   impact: ImpactCardProps
   activeMembers: BalanceCardProps
@@ -58,13 +94,15 @@ export interface GovernanceWidgetAdapterState {
   member: GovernanceMemberRecord | null
   dashboard: GovernanceDashboardState
   selectedHouse: GovernanceHouse
-  disabledHouseOptions: GovernanceHouse[]
   onboardingStepId?: GovernanceOnboardingStepId
   profileDraft: GovernanceProfileDraft
   stakeAmountLabel: string
   minimumStakeAmounts: Record<GovernanceHouse, bigint>
   transactionSteps: StepperStepItem[]
   registrationHash: Hex | null
+  transaction: GovernanceTransactionState
+  unstakeAvailability: GovernanceUnstakeAvailability
+  lifecycleNotice: string | null
   error: string | null
 }
 
@@ -75,7 +113,7 @@ export interface GovernanceWidgetAdapterActions {
   retry: () => Promise<void>
   selectHouse: (house: GovernanceHouse) => void
   register: (profileDraft: GovernanceProfileDraft) => Promise<void>
-  restake: () => Promise<void>
+  unstake: () => Promise<void>
   openVote: () => void
   closeVote: () => void
   setVoteAllocation: (recipientId: string, basisPoints: number) => void
diff --git a/tests/widgets/governance-widget/adapter-logic.spec.ts b/tests/widgets/governance-widget/adapter-logic.spec.ts
index fbee68bd..e04e10c7 100644
--- a/tests/widgets/governance-widget/adapter-logic.spec.ts
+++ b/tests/widgets/governance-widget/adapter-logic.spec.ts
@@ -1,20 +1,41 @@
 import { expect, test } from '@playwright/test'
-import type { Address, Hex, PublicClient, WalletClient } from 'viem'
 import {
   calculateStreamAmountWei,
   fetchFundingReceivedSoFar,
+  formatFundingAmountWei,
 } from '../../../packages/governance-widget/src/sdks/funding'
 import {
   encodeGovernanceRegistrationData,
   mapFlowSplitterConfig,
-  mapHoaEligibilityRecord,
   mapMemberRecord,
   mapVoteConfig,
 } from '../../../packages/governance-widget/src/sdks/contracts'
 import {
   registerWithTransferAndCall,
-  restakeWithTransferAndCall,
+  unstakeGovernanceMembership,
 } from '../../../packages/governance-widget/src/sdks/transactions'
+import {
+  readGovernanceSchedule,
+  readGovernanceVote,
+  voteStartTimeFromSchedule,
+} from '../../../packages/governance-widget/src/sdks/contractReads'
+import {
+  getUnstakeAvailability,
+  resolveRegistrationStake,
+  statusFromMember,
+} from '../../../packages/governance-widget/src/hooks/useGovernanceMembership'
+import {
+  createVotingState,
+  resolveGovernanceVoterKey,
+  validateGovernanceBallot,
+} from '../../../packages/governance-widget/src/hooks/useGovernanceVoting'
+import { selectGovernanceTransaction } from '../../../packages/governance-widget/src/adapter'
+import { getGovernanceVotingDisabledReason } from '../../../packages/governance-widget/src/widgetRuntimeContract'
+
+type Address = `0x${string}`
+type Hex = `0x${string}`
+type PublicClient = Parameters<typeof registerWithTransferAndCall>[0]['publicClient']
+type WalletClient = Parameters<typeof registerWithTransferAndCall>[0]['walletClient']
 
 const account = '0x4E5B2D7a45C2e31a8F0d09b4bE1fA11aD3aC9F08' as Address
 const houses = '0x1111111111111111111111111111111111111111' as Address
@@ -58,12 +79,6 @@ test('maps final GoodDaoHouses ABI tuples', () => {
     poolId: 9n,
     poolAddress: houses,
   })
-  expect(mapHoaEligibilityRecord([true, 10n, 20n, 0n])).toMatchObject({
-    isEligible: true,
-    listedAt: 10000,
-    updatedAt: 20000,
-    delistedAt: null,
-  })
 })
 
 test('encodes house selection in registration payload', () => {
@@ -75,8 +90,10 @@ test('encodes house selection in registration payload', () => {
   expect(alignmentData).toContain('416c69676e6d656e74')
 })
 
-test('waits for successful registration and restake receipts', async () => {
+test('waits for successful registration and unstake receipts', async () => {
   const writes: unknown[] = []
+  const registrationStages: string[] = []
+  const unstakeStages: string[] = []
   const walletClient = {
     writeContract: async (request: unknown) => {
       writes.push(request)
@@ -95,25 +112,33 @@ test('waits for successful registration and restake receipts', async () => {
     selectedHouse: 'alignment',
     profileDraft: { name: 'Alignment' },
     stakeAmountWei: 2000n,
+    onStage: (stage) => registrationStages.push(stage),
   })).resolves.toBe(hash)
 
-  await expect(restakeWithTransferAndCall({
+  await expect(unstakeGovernanceMembership({
     publicClient,
     walletClient,
     account,
-    addresses: { houses, gToken: token, goodId: account },
-    stakeAmountWei: 1000n,
+    housesAddress: houses,
+    onStage: (stage) => unstakeStages.push(stage),
   })).resolves.toBe(hash)
 
   expect(writes).toHaveLength(2)
-  expect(JSON.stringify(writes[1], (_, value) => (typeof value === 'bigint' ? value.toString() : value))).toContain('0x')
+  expect(registrationStages).toEqual(['wallet_confirmation', 'submitted', 'confirmed'])
+  expect(unstakeStages).toEqual(['wallet_confirmation', 'submitted', 'confirmed'])
+  expect(writes[1]).toMatchObject({
+    address: houses,
+    functionName: 'unstake',
+  })
 })
 
-test('does not report success for reverted transaction receipts', async () => {
+test('does not report registration or unstake success for reverted receipts', async () => {
   const walletClient = { writeContract: async () => hash } as WalletClient
   const publicClient = {
     waitForTransactionReceipt: async () => ({ status: 'reverted' }),
   } as PublicClient
+  const registrationStages: string[] = []
+  const unstakeStages: string[] = []
 
   await expect(registerWithTransferAndCall({
     publicClient,
@@ -123,7 +148,59 @@ test('does not report success for reverted transaction receipts', async () => {
     selectedHouse: 'citizenship',
     profileDraft: { name: 'Citizen' },
     stakeAmountWei: 1000n,
+    onStage: (stage) => registrationStages.push(stage),
+  })).rejects.toThrow('Transaction reverted')
+
+  await expect(unstakeGovernanceMembership({
+    publicClient,
+    walletClient,
+    account,
+    housesAddress: houses,
+    onStage: (stage) => unstakeStages.push(stage),
   })).rejects.toThrow('Transaction reverted')
+
+  expect(registrationStages).toEqual(['wallet_confirmation', 'submitted'])
+  expect(unstakeStages).toEqual(['wallet_confirmation', 'submitted'])
+})
+
+test('keeps registration and unstake in wallet confirmation when the user rejects', async () => {
+  let receiptWaits = 0
+  const walletClient = {
+    writeContract: async () => {
+      throw new Error('User rejected the request')
+    },
+  } as unknown as WalletClient
+  const publicClient = {
+    waitForTransactionReceipt: async () => {
+      receiptWaits += 1
+      return { status: 'success' }
+    },
+  } as PublicClient
+  const registrationStages: string[] = []
+  const unstakeStages: string[] = []
+
+  await expect(registerWithTransferAndCall({
+    publicClient,
+    walletClient,
+    account,
+    addresses: { houses, gToken: token, goodId: account },
+    selectedHouse: 'citizenship',
+    profileDraft: { name: 'Citizen' },
+    stakeAmountWei: 1000n,
+    onStage: (stage) => registrationStages.push(stage),
+  })).rejects.toThrow('User rejected')
+
+  await expect(unstakeGovernanceMembership({
+    publicClient,
+    walletClient,
+    account,
+    housesAddress: houses,
+    onStage: (stage) => unstakeStages.push(stage),
+  })).rejects.toThrow('User rejected')
+
+  expect(registrationStages).toEqual(['wallet_confirmation'])
+  expect(unstakeStages).toEqual(['wallet_confirmation'])
+  expect(receiptWaits).toBe(0)
 })
 
 test('aggregates active stopped multiple and paginated Superfluid streams', async () => {
@@ -155,9 +232,389 @@ test('aggregates active stopped multiple and paginated Superfluid streams', asyn
   const result = await fetchFundingReceivedSoFar({ receiver: houses, token, nowSeconds, fetcher })
   expect(calls).toBe(2)
   expect(result.streamCount).toBe(1002)
+  expect(result.activeStreamCount).toBe(1001)
   expect(result.amountWei).toBe(15025n)
 })
 
+test('formats exact funding totals without leaking unbounded token decimals into the UI', () => {
+  const token = 10n ** 18n
+
+  expect(formatFundingAmountWei(450n * token + 1n)).toBe('450')
+  expect(formatFundingAmountWei(450n * token + token / 2n)).toBe('450.5')
+  expect(formatFundingAmountWei(450n * token + 123_600_000_000_000_000n)).toBe('450.124')
+})
+
+test('distinguishes stopped historical streams from an empty funding history', async () => {
+  const stopped = await fetchFundingReceivedSoFar({
+    receiver: houses,
+    token,
+    nowSeconds: 2000n,
+    fetcher: async () => new Response(JSON.stringify({
+      data: {
+        streams: [{
+          sender: { id: account.toLowerCase() },
+          currentFlowRate: '0',
+          streamedUntilUpdatedAt: '125',
+          updatedAtTimestamp: '1900',
+        }],
+      },
+    }), { status: 200 }),
+  })
+  expect(stopped).toMatchObject({ amountWei: 125n, streamCount: 1, activeStreamCount: 0 })
+
+  const empty = await fetchFundingReceivedSoFar({
+    receiver: houses,
+    token,
+    fetcher: async () => new Response(JSON.stringify({ data: { streams: [] } }), { status: 200 }),
+  })
+  expect(empty).toMatchObject({ amountWei: 0n, streamCount: 0, activeStreamCount: 0 })
+})
+
+test('maps unstaked members to onboarding and keeps revoked members non-actionable', () => {
+  const baseMember = mapMemberRecord([
+    0,
+    2,
+    1000n,
+    100n,
+    200n,
+    0n,
+    0n,
+    'Citizen',
+    '',
+    '',
+    '',
+    '',
+  ])
+
+  expect(statusFromMember({ ...baseMember, status: 'unstaked' })).toBe('onboarding_required')
+  expect(statusFromMember({ ...baseMember, status: 'revoked' })).toBe('revoked')
+  expect(statusFromMember({ ...baseMember, status: 'pending' })).toBe('onboarding_required')
+})
+
+test('requires current membership reads before resolving a registration stake', () => {
+  const membership = {
+    member: mapMemberRecord([0, 0, 0n, 0n, 0n, 0n, 0n, '', '', '', '', '']),
+    minimumStakes: { citizenship: 1_000n, alignment: 2_000n },
+    identityRoot: account,
+    activeCitizens: [],
+    activeAlignment: [],
+  }
+
+  expect(resolveRegistrationStake(null, 'citizenship')).toEqual({
+    stakeAmountWei: null,
+    error: 'Membership data is still loading. Please try again in a moment.',
+  })
+  expect(resolveRegistrationStake(membership, 'citizenship')).toEqual({
+    stakeAmountWei: 1_000n,
+    error: null,
+  })
+  expect(resolveRegistrationStake(membership, 'alignment')).toEqual({
+    stakeAmountWei: 2_000n,
+    error: null,
+  })
+})
+
+test('prefers a pending vote over a stale terminal unstake transaction', () => {
+  const staleUnstake = { kind: 'unstake', status: 'confirmed', hash, error: null } as const
+  const pendingVote = { kind: 'vote', status: 'wallet_confirmation', hash: null, error: null } as const
+
+  expect(selectGovernanceTransaction(staleUnstake, pendingVote)).toBe(pendingVote)
+})
+
+test('enforces the exact updatedAt plus termDuration unstake boundary', () => {
+  const member = mapMemberRecord([
+    0,
+    2,
+    1000n,
+    100n,
+    200n,
+    0n,
+    0n,
+    'Citizen',
+    '',
+    '',
+    '',
+    '',
+  ])
+  const unlockAt = 200000 + 60_000
+
+  expect(getUnstakeAvailability(member, 60n, unlockAt - 1)).toMatchObject({
+    canUnstake: false,
+    unlockAt,
+  })
+  expect(getUnstakeAvailability(member, 60n, unlockAt)).toEqual({
+    canUnstake: true,
+    unlockAt,
+  })
+})
+
+test('rejects governance timestamps that cannot be represented safely', async () => {
+  const unsafeSeconds = 18_446_744_073_709_551_615n
+  const member = mapMemberRecord([
+    0,
+    2,
+    1000n,
+    100n,
+    200n,
+    0n,
+    0n,
+    'Citizen',
+    '',
+    '',
+    '',
+    '',
+  ])
+
+  expect(mapVoteConfig([unsafeSeconds, unsafeSeconds, unsafeSeconds, false])).toMatchObject({
+    startTime: null,
+    endTime: null,
+    executedAt: null,
+  })
+  expect(getUnstakeAvailability(member, unsafeSeconds, Date.UTC(2026, 6, 19))).toMatchObject({
+    canUnstake: false,
+    unlockAt: null,
+  })
+
+  const unsafeSchedule = {
+    cycleStartTime: 100_000,
+    termDurationSeconds: unsafeSeconds,
+    votingTermLengthSeconds: 50n,
+    currentBlockTime: null,
+  }
+  expect(voteStartTimeFromSchedule(unsafeSchedule, 2n)).toBeNull()
+  expect(createVotingState({
+    member,
+    identityRoot: account,
+    voteId: 2n,
+    isVotingOpen: false,
+    voteStartTime: null,
+    voteConfig: { startTime: null, endTime: null, executedAt: null, executed: false },
+    recipients: [],
+    hasVoted: false,
+    finalizedUnits: {},
+    schedule: unsafeSchedule,
+    minimumStake: 1000n,
+  }).summaryLabel).toBe('Contract schedule unavailable')
+
+  const publicClient = {
+    readContract: async ({ functionName }: { functionName: string }) => {
+      if (functionName === 'cycleStartTime') return unsafeSeconds
+      if (functionName === 'termDuration') return 100n
+      if (functionName === 'votingTermLength') return 50n
+      throw new Error(`Unexpected contract read: ${functionName}`)
+    },
+    getBlock: async () => ({ timestamp: 1_000n }),
+  } as unknown as PublicClient
+  await expect(readGovernanceSchedule({ publicClient, housesAddress: houses })).resolves.toEqual({
+    cycleStartTime: null,
+    termDurationSeconds: 100n,
+    votingTermLengthSeconds: 50n,
+    currentBlockTime: 1_000_000,
+  })
+})
+
+test('derives vote start and excludes late provisional Alignment recipients', async () => {
+  const earlyRecipient = '0x1111111111111111111111111111111111111111' as Address
+  const lateRecipient = '0x2222222222222222222222222222222222222222' as Address
+  const schedule = {
+    cycleStartTime: 1_000_000,
+    termDurationSeconds: 100n,
+    votingTermLengthSeconds: 50n,
+    currentBlockTime: 1_200_000,
+  }
+  expect(voteStartTimeFromSchedule(schedule, 0n)).toBe(1_000_000)
+  expect(voteStartTimeFromSchedule(schedule, 1n)).toBe(1_100_000)
+  expect(voteStartTimeFromSchedule(schedule, 2n)).toBe(1_200_000)
+
+  const publicClient = {
+    readContract: async ({ functionName, args }: { functionName: string; args?: readonly unknown[] }) => {
+      if (functionName === 'isVotingPeriod') return true
+      if (functionName === 'getCurrentVoteId') return 2n
+      if (functionName === 'getVoteConfig') return [0n, 0n, 0n, false]
+      if (functionName === 'getVoteRecipients') return []
+      if (functionName === 'getHasVoted') return false
+      if (functionName === 'getMember') {
+        const joinedAt = args?.[0] === earlyRecipient ? 1100n : 1300n
+        return [1, 2, 1000n, joinedAt, joinedAt, 0n, 0n, '', '', '', '', '']
+      }
+      if (functionName === 'getFinalizedUnits') return 0n
+      throw new Error(`Unexpected contract read: ${functionName}`)
+    },
+  } as unknown as PublicClient
+
+  const result = await readGovernanceVote({
+    publicClient,
+    housesAddress: houses,
+    voterKey: account,
+    activeAlignment: [earlyRecipient, lateRecipient],
+    schedule,
+  })
+  expect(result.voteStartTime).toBe(1_200_000)
+  expect(result.recipients).toEqual([earlyRecipient])
+})
+
+test('requires voters to have joined before vote start and validates exact ballots', () => {
+  const recipient = '0x1111111111111111111111111111111111111111' as Address
+  const member = mapMemberRecord([
+    0,
+    2,
+    1000n,
+    100n,
+    100n,
+    0n,
+    0n,
+    'Citizen',
+    '',
+    '',
+    '',
+    '',
+  ])
+  const schedule = {
+    cycleStartTime: 100000,
+    termDurationSeconds: 100n,
+    votingTermLengthSeconds: 50n,
+    currentBlockTime: 150000,
+  }
+  const voting = createVotingState({
+    member,
+    identityRoot: account,
+    voteId: 0n,
+    isVotingOpen: true,
+    voteStartTime: 150000,
+    voteConfig: { startTime: 150000, endTime: 200000, executedAt: null, executed: false },
+    recipients: [recipient],
+    hasVoted: false,
+    finalizedUnits: { [recipient]: 0n },
+    schedule,
+    minimumStake: 1000n,
+  })
+  expect(voting.canVote).toBe(true)
+
+  const lateVoting = createVotingState({
+    ...{
+      member: { ...member, joinedAt: 150001 },
+      identityRoot: account,
+      voteId: 0n,
+      isVotingOpen: true,
+      voteStartTime: 150000,
+      voteConfig: { startTime: 150000, endTime: 200000, executedAt: null, executed: false },
+      recipients: [recipient],
+      hasVoted: false,
+      finalizedUnits: { [recipient]: 0n },
+      schedule,
+      minimumStake: 1000n,
+    },
+  })
+  expect(lateVoting.canVote).toBe(false)
+  expect(lateVoting.disabledReason).toContain('joined after')
+
+  expect(resolveGovernanceVoterKey(member, account, houses)).toBe(account)
+  expect(resolveGovernanceVoterKey({ ...member, house: 'alignment' }, account, houses)).toBe(houses)
+
+  const unverifiedCitizenVoting = createVotingState({
+    member,
+    identityRoot: null,
+    voteId: 0n,
+    isVotingOpen: true,
+    voteStartTime: 150000,
+    voteConfig: { startTime: 150000, endTime: 200000, executedAt: null, executed: false },
+    recipients: [recipient],
+    hasVoted: false,
+    finalizedUnits: { [recipient]: 0n },
+    schedule,
+    minimumStake: 1000n,
+  })
+  expect(unverifiedCitizenVoting.canVote).toBe(false)
+  expect(unverifiedCitizenVoting.disabledReason).toContain('GoodID')
+  expect(getGovernanceVotingDisabledReason({
+    ...unverifiedCitizenVoting,
+    allocationTotalBps: 9_999,
+  })).toContain('GoodID')
+
+  const alignmentVoting = createVotingState({
+    member: { ...member, house: 'alignment' },
+    identityRoot: null,
+    voteId: 0n,
+    isVotingOpen: true,
+    voteStartTime: 150000,
+    voteConfig: { startTime: 150000, endTime: 200000, executedAt: null, executed: false },
+    recipients: [recipient],
+    hasVoted: false,
+    finalizedUnits: { [recipient]: 0n },
+    schedule,
+    minimumStake: 1000n,
+  })
+  expect(alignmentVoting.canVote).toBe(true)
+  expect(getGovernanceVotingDisabledReason(alignmentVoting)).toContain('10,000 basis points')
+  expect(getGovernanceVotingDisabledReason({
+    ...alignmentVoting,
+    allocationTotalBps: 10_000,
+  })).toBeUndefined()
+
+  expect(validateGovernanceBallot([recipient], { [recipient]: 10_000 })).toEqual({
+    recipients: [recipient],
+    allocations: [10_000n],
+  })
+  expect(() => validateGovernanceBallot([recipient], { [recipient]: 9_999 })).toThrow(
+    'Alloc != 10000',
+  )
+  expect(() => validateGovernanceBallot([recipient, recipient], { [recipient]: 10_000 })).toThrow(
+    'Duplicate recipient',
+  )
+  expect(() => validateGovernanceBallot([recipient], { [recipient]: 10_000.5 })).toThrow(
+    'Invalid allocation',
+  )
+})
+
+test('requires the current minimum stake for voters from either house', () => {
+  const recipient = '0x1111111111111111111111111111111111111111' as Address
+  const schedule = {
+    cycleStartTime: 100000,
+    termDurationSeconds: 100n,
+    votingTermLengthSeconds: 50n,
+    currentBlockTime: 150000,
+  }
+  const baseMember = mapMemberRecord([
+    0,
+    2,
+    1000n,
+    100n,
+    100n,
+    0n,
+    0n,
+    'Member',
+    '',
+    '',
+    '',
+    '',
+  ])
+
+  for (const house of ['citizenship', 'alignment'] as const) {
+    for (const [stakedAmount, expected] of [
+      [999n, false],
+      [1000n, true],
+      [1001n, true],
+    ] as const) {
+      const voting = createVotingState({
+        member: { ...baseMember, house, stakedAmount },
+        identityRoot: house === 'citizenship' ? account : null,
+        voteId: 0n,
+        isVotingOpen: true,
+        voteStartTime: 150000,
+        voteConfig: { startTime: 150000, endTime: 200000, executedAt: null, executed: false },
+        recipients: [recipient],
+        hasVoted: false,
+        finalizedUnits: { [recipient]: 0n },
+        schedule,
+        minimumStake: 1000n,
+      })
+
+      expect(voting.canVote).toBe(expected)
+      if (!expected) expect(voting.disabledReason).toContain('below the current minimum')
+    }
+  }
+})
+
 test('surfaces failed Superfluid stream queries', async () => {
   await expect(fetchFundingReceivedSoFar({
     receiver: houses,
diff --git a/tests/widgets/governance-widget/onboarding.spec.ts b/tests/widgets/governance-widget/onboarding.spec.ts
index 31f620d5..27e60f93 100644
--- a/tests/widgets/governance-widget/onboarding.spec.ts
+++ b/tests/widgets/governance-widget/onboarding.spec.ts
@@ -23,37 +23,44 @@ async function gotoStory(page: Page, storyUrl: string): Promise<void> {
   await page.goto(storyUrl)
   await page.waitForLoadState('domcontentloaded')
   await page.waitForLoadState('networkidle')
+  await page.addStyleTag({
+    content: '*, *::before, *::after { animation: none !important; transition: none !important; caret-color: transparent !important; }',
+  })
+}
+
+async function captureEvidence(page: Page, path: string): Promise<void> {
+  for (let attempt = 1; attempt <= 3; attempt += 1) {
+    try {
+      await page.screenshot({ path, fullPage: true })
+      return
+    } catch (error: unknown) {
+      if (attempt === 3) throw error
+      await page.waitForTimeout(attempt * 100)
+    }
+  }
 }
 
 test('Governance onboarding interactive flow persists selected house into profile and success steps', async ({
   page,
 }) => {
+  await page.clock.install({ time: new Date('2026-07-19T12:00:00Z') })
   await gotoStory(page, STORY_IDS.custodialInteractiveFlow)
 
   await expect(page.getByText('Welcome', { exact: true })).toBeVisible()
   await page.getByRole('button', { name: 'Proceed to Membership' }).scrollIntoViewIfNeeded()
   await expect(page.getByRole('button', { name: 'Proceed to Membership' })).toBeEnabled()
-  await page.screenshot({
-    path: 'tests/widgets/governance-widget/test-results/gwo-01-welcome-verified.png',
-    fullPage: true,
-  })
+  await captureEvidence(page, 'tests/widgets/governance-widget/test-results/gwo-01-welcome-verified.png')
 
   await page.getByRole('button', { name: 'Proceed to Membership' }).click()
   await expect(page.getByText('Choose your house', { exact: true })).toBeVisible()
-  await page.screenshot({
-    path: 'tests/widgets/governance-widget/test-results/gwo-02-house-selection.png',
-    fullPage: true,
-  })
+  await captureEvidence(page, 'tests/widgets/governance-widget/test-results/gwo-02-house-selection.png')
 
   await page.getByTestId('GovernanceOnboardingWidget-house-alignment').click()
-  await page.getByRole('button', { name: 'Continue to profile' }).scrollIntoViewIfNeeded()
-  await page.getByRole('button', { name: 'Continue to profile' }).click({ force: true })
+  await page.getByRole('button', { name: 'Continue', exact: true }).scrollIntoViewIfNeeded()
+  await page.getByRole('button', { name: 'Continue', exact: true }).click({ force: true })
   await expect(page.getByText('Apply for House of Alignment', { exact: true })).toBeVisible()
   await expect(page.getByText('Mission statement')).toBeVisible()
-  await page.screenshot({
-    path: 'tests/widgets/governance-widget/test-results/gwo-03-profile-alignment.png',
-    fullPage: true,
-  })
+  await captureEvidence(page, 'tests/widgets/governance-widget/test-results/gwo-03-profile-alignment.png')
 
   await page.getByPlaceholder('John Doe or Organization').fill('Solar Commons')
   await page.getByPlaceholder('https://example.com').fill('https://solar.example')
@@ -70,63 +77,45 @@ test('Governance onboarding interactive flow persists selected house into profil
     .scrollIntoViewIfNeeded()
   await page.getByRole('button', { name: 'Create Profile and Stake' }).click({ force: true })
 
-  await expect(page.getByText('Creating profile & staking', { exact: true }).first()).toBeVisible()
+  await expect(page.getByText('Securing your membership', { exact: true }).first()).toBeVisible()
   await expect(page.getByText('Approve governance stake')).toBeVisible()
-  await page.screenshot({
-    path: 'tests/widgets/governance-widget/test-results/gwo-04-stake-progress-active.png',
-    fullPage: true,
-  })
+  await captureEvidence(page, 'tests/widgets/governance-widget/test-results/gwo-04-stake-progress-active.png')
 
-  await page.getByRole('button', { name: 'Continue to success' }).scrollIntoViewIfNeeded()
-  // Wait for all transaction steps to complete (indicated by the progress text reaching 4/4)
+  await page.clock.runFor(1_500)
   await expect(page.getByText('4/4')).toBeVisible({ timeout: 10000 })
+  await page.getByRole('button', { name: 'Continue to success' }).scrollIntoViewIfNeeded()
   await expect(page.getByRole('button', { name: 'Continue to success' })).toBeEnabled()
   await page.getByRole('button', { name: 'Continue to success' }).click({ force: true })
   await expect(page.getByText('Welcome to Governance', { exact: true })).toBeVisible()
-  await page.screenshot({
-    path: 'tests/widgets/governance-widget/test-results/gwo-05-success.png',
-    fullPage: true,
-  })
+  await captureEvidence(page, 'tests/widgets/governance-widget/test-results/gwo-05-success.png')
 })
 
 test('Governance onboarding shows the unverified welcome state', async ({ page }) => {
   await gotoStory(page, STORY_IDS.custodialWelcomeUnverified)
   await expect(page.getByText('Verification required')).toBeVisible()
   await expect(page.getByRole('button', { name: 'Verify with GoodID' })).toBeVisible()
-  await page.screenshot({
-    path: 'tests/widgets/governance-widget/test-results/gwo-06-welcome-unverified.png',
-    fullPage: true,
-  })
+  await captureEvidence(page, 'tests/widgets/governance-widget/test-results/gwo-06-welcome-unverified.png')
 })
 
 test('Governance onboarding shows house selection as a standalone state', async ({ page }) => {
   await gotoStory(page, STORY_IDS.custodialHouseSelection)
   await expect(page.getByText('House of Citizenship')).toBeVisible()
   await expect(page.getByText('House of Alignment')).toBeVisible()
-  await page.screenshot({
-    path: 'tests/widgets/governance-widget/test-results/gwo-07-house-selection-standalone.png',
-    fullPage: true,
-  })
+  await captureEvidence(page, 'tests/widgets/governance-widget/test-results/gwo-07-house-selection-standalone.png')
 })
 
 test('Governance onboarding shows the citizenship profile ready state', async ({ page }) => {
   await gotoStory(page, STORY_IDS.custodialCitizenshipProfileReady)
   await expect(page.getByRole('button', { name: 'Create Profile and Stake' })).toBeVisible()
   await expect(page.getByRole('button', { name: 'Create Profile and Stake' })).toBeEnabled()
-  await page.screenshot({
-    path: 'tests/widgets/governance-widget/test-results/gwo-08-profile-citizenship-ready.png',
-    fullPage: true,
-  })
+  await captureEvidence(page, 'tests/widgets/governance-widget/test-results/gwo-08-profile-citizenship-ready.png')
 })
 
 test('Governance onboarding shows the alignment profile validation state', async ({ page }) => {
   await gotoStory(page, STORY_IDS.custodialAlignmentProfileError)
   await expect(page.getByText('Project webpage is required')).toBeVisible()
   await expect(page.getByText('Distribution strategy is required')).toBeVisible()
-  await page.screenshot({
-    path: 'tests/widgets/governance-widget/test-results/gwo-09-profile-alignment-error.png',
-    fullPage: true,
-  })
+  await captureEvidence(page, 'tests/widgets/governance-widget/test-results/gwo-09-profile-alignment-error.png')
 })
 
 test('Governance onboarding shows the failed stake progress state', async ({ page }) => {
@@ -135,20 +124,14 @@ test('Governance onboarding shows the failed stake progress state', async ({ pag
   await expect(
     page.getByText('The previous transaction failed and needs a retry from the wallet.').first(),
   ).toBeVisible()
-  await page.screenshot({
-    path: 'tests/widgets/governance-widget/test-results/gwo-10-stake-progress-failed.png',
-    fullPage: true,
-  })
+  await captureEvidence(page, 'tests/widgets/governance-widget/test-results/gwo-10-stake-progress-failed.png')
 })
 
 test('Governance onboarding shows the standalone success state actions', async ({ page }) => {
   await gotoStory(page, STORY_IDS.custodialSuccess)
   await expect(page.getByRole('button', { name: 'Explore Governance Proposals' })).toBeVisible()
   await expect(page.getByRole('button', { name: 'Go to my profile' })).toBeVisible()
-  await page.screenshot({
-    path: 'tests/widgets/governance-widget/test-results/gwo-11-success-standalone.png',
-    fullPage: true,
-  })
+  await captureEvidence(page, 'tests/widgets/governance-widget/test-results/gwo-11-success-standalone.png')
 })
 
 test('Profile field handles rapid typing without losing characters (stale-closure regression)', async ({
@@ -160,8 +143,8 @@ test('Profile field handles rapid typing without losing characters (stale-closur
   await page.getByRole('button', { name: 'Proceed to Membership' }).scrollIntoViewIfNeeded()
   await page.getByRole('button', { name: 'Proceed to Membership' }).click()
   await page.getByTestId('GovernanceOnboardingWidget-house-alignment').click()
-  await page.getByRole('button', { name: 'Continue to profile' }).scrollIntoViewIfNeeded()
-  await page.getByRole('button', { name: 'Continue to profile' }).click({ force: true })
+  await page.getByRole('button', { name: 'Continue', exact: true }).scrollIntoViewIfNeeded()
+  await page.getByRole('button', { name: 'Continue', exact: true }).click({ force: true })
   await expect(page.getByText('Apply for House of Alignment', { exact: true })).toBeVisible()
 
   const nameInput = page.getByPlaceholder('John Doe or Organization')
diff --git a/tests/widgets/governance-widget/runtime.spec.ts b/tests/widgets/governance-widget/runtime.spec.ts
index 0a738a3e..e1d8bca5 100644
--- a/tests/widgets/governance-widget/runtime.spec.ts
+++ b/tests/widgets/governance-widget/runtime.spec.ts
@@ -1,4 +1,18 @@
 import { expect, test, type Page } from '@playwright/test'
+import {
+  MOCK_ALIGNMENT,
+  MOCK_CITIZEN,
+  MOCK_HOUSES,
+  encodeMockGovernanceRead,
+} from '../../../examples/storybook/src/fixtures/governanceRuntimeMock'
+import {
+  G_TOKEN_ABI,
+  G_TOKEN_CELO_ADDRESS,
+} from '../../../packages/governance-widget/src/sdks/contracts'
+import { decodeAbiParameters, decodeFunctionData } from 'viem'
+
+type Address = `0x${string}`
+type Hex = `0x${string}`
 
 type RuntimeStoryCase = {
   id: string
@@ -6,6 +20,7 @@ type RuntimeStoryCase = {
   expectedText: string
   screenshot: string
   mockInjected?: boolean
+  mockRuntime?: boolean
 }
 
 const RUNTIME_STORIES: RuntimeStoryCase[] = [
@@ -22,10 +37,10 @@ const RUNTIME_STORIES: RuntimeStoryCase[] = [
     screenshot: 'tests/widgets/governance-widget/test-results/gwr-02-loading-connected.png',
   },
   {
-    id: 'qa-governancewidget-runtime-fixtures--onboarding-required-hoa-unavailable',
+    id: 'qa-governancewidget-runtime-fixtures--onboarding-house-selection',
     testId: 'GovernanceWidget-onboarding',
     expectedText: 'House of Alignment',
-    screenshot: 'tests/widgets/governance-widget/test-results/gwr-03-onboarding-hoa-unavailable.png',
+    screenshot: 'tests/widgets/governance-widget/test-results/gwr-03-onboarding-house-selection.png',
   },
   {
     id: 'qa-governancewidget-runtime-fixtures--pending-alignment',
@@ -83,10 +98,10 @@ const RUNTIME_STORIES: RuntimeStoryCase[] = [
     screenshot: 'tests/widgets/governance-widget/test-results/gwr-12-unsupported-chain.png',
   },
   {
-    id: 'qa-governancewidget-runtime-fixtures--restake-required',
-    testId: 'GovernanceWidget-restake',
-    expectedText: 'Restore governance membership',
-    screenshot: 'tests/widgets/governance-widget/test-results/gwr-13-restake-required.png',
+    id: 'qa-governancewidget-runtime-fixtures--active-membership-unstake-ready',
+    testId: 'GovernanceWidget-unstake',
+    expectedText: 'Unstake membership',
+    screenshot: 'tests/widgets/governance-widget/test-results/gwr-13-unstake-ready.png',
   },
   {
     id: 'qa-governancewidget-runtime-fixtures--friendly-contract-error',
@@ -94,23 +109,299 @@ const RUNTIME_STORIES: RuntimeStoryCase[] = [
     expectedText: 'Governance data unavailable',
     screenshot: 'tests/widgets/governance-widget/test-results/gwr-14-friendly-contract-error.png',
   },
+  {
+    id: 'qa-governancewidget-runtime-fixtures--unstake-wallet-confirmation',
+    testId: 'GovernanceWidget-unstake',
+    expectedText: 'Confirm the unstake transaction in your wallet.',
+    screenshot: 'tests/widgets/governance-widget/test-results/gwr-16-unstake-wallet-confirmation.png',
+  },
+  {
+    id: 'qa-governancewidget-runtime-fixtures--unstake-submitted',
+    testId: 'GovernanceWidget-unstake',
+    expectedText: 'Waiting for a successful Celo receipt',
+    screenshot: 'tests/widgets/governance-widget/test-results/gwr-17-unstake-submitted.png',
+  },
+  {
+    id: 'qa-governancewidget-runtime-fixtures--unstake-rejected',
+    testId: 'GovernanceWidget-unstake',
+    expectedText: 'Transaction rejected in the wallet.',
+    screenshot: 'tests/widgets/governance-widget/test-results/gwr-18-unstake-rejected.png',
+  },
+  {
+    id: 'qa-governancewidget-runtime-fixtures--unstaked-returns-to-onboarding',
+    testId: 'GovernanceWidget-lifecycle-notice',
+    expectedText: 'Membership unstaked successfully.',
+    screenshot: 'tests/widgets/governance-widget/test-results/gwr-19-unstaked-onboarding.png',
+  },
+  {
+    id: 'qa-governancewidget-runtime-fixtures--revoked-membership',
+    testId: 'GovernanceWidget-revoked',
+    expectedText: 'cannot be reactivated from the widget',
+    screenshot: 'tests/widgets/governance-widget/test-results/gwr-20-revoked.png',
+  },
+  {
+    id: 'qa-governancewidget-runtime-fixtures--real-adapter-mocked-runtime',
+    testId: 'GovernanceWidget-real-adapter',
+    expectedText: 'House of Citizenship',
+    screenshot: 'tests/widgets/governance-widget/test-results/gwr-21-real-adapter-mocked-runtime.png',
+    mockRuntime: true,
+  },
+  {
+    id: 'qa-governancewidget-runtime-fixtures--upcoming-vote',
+    testId: 'GovernanceWidget-active-governance',
+    expectedText: 'Next window starts Aug 1, 2026',
+    screenshot: 'tests/widgets/governance-widget/test-results/gwr-22-upcoming-vote.png',
+  },
+  {
+    id: 'qa-governancewidget-runtime-fixtures--unstake-reverted',
+    testId: 'GovernanceWidget-unstake',
+    expectedText: 'The governance contract rejected this action.',
+    screenshot: 'tests/widgets/governance-widget/test-results/gwr-23-unstake-reverted.png',
+  },
 ]
 
-async function installInjectedProvider(page: Page): Promise<void> {
-  await page.addInitScript(() => {
+const MOCK_TRANSACTION_HASH = '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'
+const MOCK_NOW_SECONDS = 1_784_419_200
+const MOCK_ACCOUNT = '0x4E5B2D7a45C2e31a8F0d09b4bE1fA11aD3aC9F08'
+const MOCK_SWITCHED_ACCOUNT = '0x9999999999999999999999999999999999999999'
+
+async function installInjectedProvider(
+  page: Page,
+  options: { rejectTransactions?: boolean } = {},
+): Promise<void> {
+  await page.addInitScript(({ rejectTransactions, transactionHash }) => {
+    const runtimeWindow = window as typeof window & {
+      __governanceSentTransactions?: unknown[]
+      __switchGovernanceAccount?: (account: string) => void
+    }
+    let currentAccount = '0x4E5B2D7a45C2e31a8F0d09b4bE1fA11aD3aC9F08'
+    const accountListeners = new Set<(accounts: string[]) => void>()
+    runtimeWindow.__governanceSentTransactions = []
+    runtimeWindow.__switchGovernanceAccount = (account) => {
+      currentAccount = account
+      accountListeners.forEach((listener) => listener([account]))
+    }
     window.ethereum = {
-      request: async ({ method }: { method: string }) => {
+      request: async ({ method, params }: { method: string; params?: unknown[] }) => {
         if (method === 'eth_accounts' || method === 'eth_requestAccounts') {
-          return ['0x4E5B2D7a45C2e31a8F0d09b4bE1fA11aD3aC9F08']
+          return [currentAccount]
         }
         if (method === 'eth_chainId') return '0xa4ec'
         if (method === 'wallet_switchEthereumChain') return null
+        if (method === 'eth_estimateGas') return '0x5208'
+        if (method === 'eth_sendTransaction') {
+          if (rejectTransactions) throw new Error('User rejected the request')
+          runtimeWindow.__governanceSentTransactions?.push(params?.[0])
+          return transactionHash
+        }
         return null
       },
-      on: () => {},
-      removeListener: () => {},
+      on: (event: string, listener: (...args: unknown[]) => void) => {
+        if (event === 'accountsChanged') {
+          accountListeners.add(listener as (accounts: string[]) => void)
+        }
+      },
+      removeListener: (event: string, listener: (...args: unknown[]) => void) => {
+        if (event === 'accountsChanged') {
+          accountListeners.delete(listener as (accounts: string[]) => void)
+        }
+      },
+    }
+  }, { rejectTransactions: Boolean(options.rejectTransactions), transactionHash: MOCK_TRANSACTION_HASH })
+}
+
+async function installGovernanceRuntimeMocks(
+  page: Page,
+  options: {
+    receiptStatus?: 'success' | 'reverted'
+    clearMemberAfterReceipt?: boolean
+    initialMemberStatus?: 0 | 1 | 2
+    memberStatusAfterReceipt?: 0 | 1 | 2
+    memberHouse?: 0 | 1
+  } = {},
+): Promise<{
+  pauseReads: () => void
+  resumeReads: () => void
+  pauseReceipts: () => void
+  resumeReceipts: () => void
+  receiptRequestCount: () => number
+}> {
+  const memberStatusByAccount: Record<string, 0 | 1 | 2> = {
+    [MOCK_ACCOUNT.toLowerCase()]: options.initialMemberStatus ?? 2,
+    [MOCK_SWITCHED_ACCOUNT.toLowerCase()]: 2,
+  }
+  const memberHouseByAccount: Record<string, 0 | 1> = {
+    [MOCK_ACCOUNT.toLowerCase()]: options.memberHouse ?? 0,
+    [MOCK_SWITCHED_ACCOUNT.toLowerCase()]: 0,
+  }
+  let readsPaused = false
+  let resumePendingReads: (() => void) | null = null
+  let pendingReads = Promise.resolve()
+  let receiptsPaused = false
+  let resumePendingReceipts: (() => void) | null = null
+  let pendingReceipts = Promise.resolve()
+  let receiptRequests = 0
+  const controls = {
+    pauseReads: () => {
+      if (readsPaused) return
+      readsPaused = true
+      pendingReads = new Promise<void>((resolve) => {
+        resumePendingReads = resolve
+      })
+    },
+    resumeReads: () => {
+      readsPaused = false
+      resumePendingReads?.()
+      resumePendingReads = null
+    },
+    pauseReceipts: () => {
+      if (receiptsPaused) return
+      receiptsPaused = true
+      pendingReceipts = new Promise<void>((resolve) => {
+        resumePendingReceipts = resolve
+      })
+    },
+    resumeReceipts: () => {
+      receiptsPaused = false
+      resumePendingReceipts?.()
+      resumePendingReceipts = null
+    },
+    receiptRequestCount: () => receiptRequests,
+  }
+  await page.route('**/mock-governance-rpc', async (route) => {
+    const request = route.request()
+    const payload = request.postDataJSON() as {
+      id: number
+      method: string
+      params?: Array<{ to?: Address; data?: Hex }>
+    }
+    if (payload.method === 'eth_getTransactionReceipt') {
+      receiptRequests += 1
+      if (receiptsPaused) await pendingReceipts
+      if (options.receiptStatus !== 'reverted') {
+        if (options.memberStatusAfterReceipt !== undefined) {
+          memberStatusByAccount[MOCK_ACCOUNT.toLowerCase()] = options.memberStatusAfterReceipt
+        } else if (options.clearMemberAfterReceipt) {
+          memberStatusByAccount[MOCK_ACCOUNT.toLowerCase()] = 0
+        }
+      }
+      await route.fulfill({
+        contentType: 'application/json',
+        body: JSON.stringify({
+          jsonrpc: '2.0',
+          id: payload.id,
+          result: {
+            blockHash: '0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb',
+            blockNumber: '0x10',
+            contractAddress: null,
+            cumulativeGasUsed: '0x5208',
+            effectiveGasPrice: '0x1',
+            from: '0x4E5B2D7a45C2e31a8F0d09b4bE1fA11aD3aC9F08',
+            gasUsed: '0x5208',
+            logs: [],
+            logsBloom: `0x${'0'.repeat(512)}`,
+            status: options.receiptStatus === 'reverted' ? '0x0' : '0x1',
+            to: MOCK_HOUSES,
+            transactionHash: MOCK_TRANSACTION_HASH,
+            transactionIndex: '0x0',
+            type: '0x2',
+          },
+        }),
+      })
+      return
+    }
+    if (payload.method === 'eth_getBlockByNumber') {
+      await route.fulfill({
+        contentType: 'application/json',
+        body: JSON.stringify({
+          jsonrpc: '2.0',
+          id: payload.id,
+          result: {
+            baseFeePerGas: '0x0',
+            difficulty: '0x0',
+            extraData: '0x',
+            gasLimit: '0x1c9c380',
+            gasUsed: '0x0',
+            hash: '0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb',
+            logsBloom: `0x${'0'.repeat(512)}`,
+            miner: MOCK_HOUSES,
+            mixHash: '0xcccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc',
+            nonce: '0x0000000000000000',
+            number: '0x10',
+            parentHash: '0xdddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd',
+            receiptsRoot: '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee',
+            sha3Uncles: '0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff',
+            size: '0x0',
+            stateRoot: '0x1111111111111111111111111111111111111111111111111111111111111111',
+            timestamp: `0x${MOCK_NOW_SECONDS.toString(16)}`,
+            totalDifficulty: '0x0',
+            transactions: [],
+            transactionsRoot: '0x2222222222222222222222222222222222222222222222222222222222222222',
+            uncles: [],
+          },
+        }),
+      })
+      return
+    }
+    if (payload.method === 'eth_blockNumber') {
+      await route.fulfill({
+        contentType: 'application/json',
+        body: JSON.stringify({ jsonrpc: '2.0', id: payload.id, result: '0x10' }),
+      })
+      return
+    }
+    if (payload.method !== 'eth_call') {
+      await route.fulfill({
+        contentType: 'application/json',
+        body: JSON.stringify({ jsonrpc: '2.0', id: payload.id, result: '0x' }),
+      })
+      return
     }
+
+    if (readsPaused) await pendingReads
+
+    const call = payload.params?.[0]
+    if (!call?.to || !call.data) throw new Error('Mock eth_call is missing to/data')
+    let result: Hex
+    try {
+      result = encodeMockGovernanceRead(call.to, call.data, {
+        memberStatusByAccount,
+        memberHouseByAccount,
+      })
+    } catch (error) {
+      console.error(`Governance RPC mock failed for ${call.to} ${call.data}: ${String(error)}`)
+      throw error
+    }
+    await route.fulfill({
+      contentType: 'application/json',
+      body: JSON.stringify({ jsonrpc: '2.0', id: payload.id, result }),
+    })
   })
+
+  await page.route('**/celo-mainnet/protocol-v1', async (route) => {
+    await route.fulfill({
+      contentType: 'application/json',
+      body: JSON.stringify({
+        data: {
+          streams: [
+            {
+              sender: { id: MOCK_CITIZEN.toLowerCase() },
+              currentFlowRate: '0',
+              streamedUntilUpdatedAt: '300000000000000000000',
+              updatedAtTimestamp: String(MOCK_NOW_SECONDS),
+            },
+            {
+              sender: { id: MOCK_ALIGNMENT.toLowerCase() },
+              currentFlowRate: '1',
+              streamedUntilUpdatedAt: '150000000000000000000',
+              updatedAtTimestamp: String(MOCK_NOW_SECONDS),
+            },
+          ],
+        },
+      }),
+    })
+  })
+  return controls
 }
 
 async function gotoStory(page: Page, storyId: string): Promise<void> {
@@ -118,6 +409,57 @@ async function gotoStory(page: Page, storyId: string): Promise<void> {
   await page.waitForLoadState('domcontentloaded')
   await page.locator('#storybook-root').waitFor({ state: 'attached' })
   await page.waitForLoadState('networkidle')
+  await page.addStyleTag({
+    content: '*, *::before, *::after { animation: none !important; transition: none !important; caret-color: transparent !important; }',
+  })
+}
+
+function logRuntimeDiagnostics(page: Page): void {
+  page.on('pageerror', (error) => console.error(`Governance runtime page error: ${error.message}`))
+  page.on('console', (message) => {
+    if (message.type() === 'error') console.error(`Governance runtime console error: ${message.text()}`)
+  })
+  page.on('requestfailed', (request) => {
+    console.error(`Governance runtime request failed: ${request.method()} ${request.url()} ${request.failure()?.errorText}`)
+  })
+}
+
+async function captureEvidence(page: Page, path: string): Promise<void> {
+  for (let attempt = 1; attempt <= 3; attempt += 1) {
+    try {
+      await page.screenshot({ path, fullPage: true })
+      return
+    } catch (error: unknown) {
+      if (attempt === 3) throw error
+      await page.waitForTimeout(attempt * 100)
+    }
+  }
+}
+
+async function submitCitizenshipRegistration(page: Page): Promise<void> {
+  await expect(page.getByTestId('GovernanceWidget-onboarding')).toBeVisible()
+  await page.getByRole('button', { name: 'Proceed to Membership' }).click()
+  await page.getByTestId('GovernanceOnboardingWidget-house-citizenship').click()
+  await page.getByRole('button', { name: 'Continue', exact: true }).click()
+  await page.getByPlaceholder('John Doe or Organization').fill('Mocked Citizen')
+  await page.getByPlaceholder('https://twitter.com/username').fill('https://twitter.com/mockcitizen')
+  await page.getByRole('button', { name: 'Create Profile and Stake' }).click()
+}
+
+async function submitAlignmentRegistration(page: Page): Promise<void> {
+  await expect(page.getByTestId('GovernanceWidget-onboarding')).toBeVisible()
+  await page.getByRole('button', { name: 'Proceed to Membership' }).click()
+  await page.getByTestId('GovernanceOnboardingWidget-house-alignment').click()
+  await page.getByRole('button', { name: 'Continue', exact: true }).click()
+  await page.getByPlaceholder('John Doe or Organization').fill('Mocked Alignment')
+  await page.getByPlaceholder('https://example.com').fill('https://alignment.example')
+  await page.getByPlaceholder('What is the primary goal of your alignment?').fill(
+    'Fund public goods through transparent community governance.',
+  )
+  await page.getByPlaceholder('How do you plan to allocate resources?').fill(
+    'Allocate resources through quarterly community-approved votes.',
+  )
+  await page.getByRole('button', { name: 'Create Profile and Stake' }).click()
 }
 
 for (const storyCase of RUNTIME_STORIES) {
@@ -126,25 +468,284 @@ for (const storyCase of RUNTIME_STORIES) {
     if (storyCase.mockInjected) {
       await installInjectedProvider(page)
     }
+    if (storyCase.mockRuntime) {
+      await page.clock.install({ time: MOCK_NOW_SECONDS * 1000 })
+      await installInjectedProvider(page)
+      logRuntimeDiagnostics(page)
+      await installGovernanceRuntimeMocks(page)
+    }
 
     await gotoStory(page, storyCase.id)
 
     await expect(page.getByTestId(storyCase.testId).first()).toBeVisible({ timeout: 15_000 })
     await expect(page.getByText(storyCase.expectedText).first()).toBeVisible()
-    await page.screenshot({ path: storyCase.screenshot, fullPage: true })
+    if (storyCase.mockRuntime) {
+      await expect(page.getByTestId('GovernanceWidget-funding-distribution')).toContainText('450')
+    }
+    await captureEvidence(page, storyCase.screenshot)
   })
 }
 
-test('onboarding runtime fixture greys out House of Alignment for non-whitelisted wallets', async ({
+test('onboarding allows either house and keeps the contract-derived stake for the selection', async ({
   page,
 }) => {
-  await gotoStory(page, 'qa-governancewidget-runtime-fixtures--onboarding-required-hoa-unavailable')
+  await gotoStory(page, 'qa-governancewidget-runtime-fixtures--onboarding-house-selection')
 
   const alignmentCard = page.getByTestId('GovernanceOnboardingWidget-house-alignment')
+  const citizenshipCard = page.getByTestId('GovernanceOnboardingWidget-house-citizenship')
   await expect(alignmentCard).toBeVisible()
-  await expect(alignmentCard).toHaveCSS('pointer-events', 'none')
-  await page.screenshot({
-    path: 'tests/widgets/governance-widget/test-results/gwr-15-hoa-greyed-out.png',
-    fullPage: true,
+  await expect(citizenshipCard).toBeVisible()
+  await expect(alignmentCard).toHaveCSS('pointer-events', 'auto')
+  await expect(citizenshipCard).toHaveCSS('pointer-events', 'auto')
+
+  await alignmentCard.click()
+  await expect(alignmentCard).toHaveAttribute('aria-checked', 'true')
+  await expect(alignmentCard).toContainText('500 G$ stake')
+  await captureEvidence(page, 'tests/widgets/governance-widget/test-results/gwr-15-both-houses-available.png')
+})
+
+test('active membership keeps unstake disabled until the contract unlock boundary', async ({
+  page,
+}) => {
+  await gotoStory(page, 'qa-governancewidget-runtime-fixtures--active-citizenship')
+
+  await expect(page.getByTestId('GovernanceWidget-unstake-locked')).toBeVisible()
+  await expect(page.getByRole('button', { name: 'Unstake membership' })).toBeDisabled()
+})
+
+test('active membership enables unstake after the contract unlock boundary', async ({ page }) => {
+  await gotoStory(page, 'qa-governancewidget-runtime-fixtures--active-membership-unstake-ready')
+
+  await expect(page.getByRole('button', { name: 'Unstake membership' })).toBeEnabled()
+})
+
+test('real adapter registers a no-member after a successful receipt', async ({ page }) => {
+  logRuntimeDiagnostics(page)
+  await page.clock.install({ time: MOCK_NOW_SECONDS * 1000 })
+  await installInjectedProvider(page)
+  await installGovernanceRuntimeMocks(page, {
+    initialMemberStatus: 0,
+    memberStatusAfterReceipt: 2,
+  })
+  await gotoStory(page, 'qa-governancewidget-runtime-fixtures--real-adapter-mocked-runtime')
+
+  await submitCitizenshipRegistration(page)
+
+  await expect(page.getByTestId('GovernanceWidget-dashboard')).toBeVisible()
+  await expect(page.getByTestId('GovernanceWidget-member-footer')).toContainText('House of Citizenship')
+  const sentTransactions = await page.evaluate(() => (
+    window as typeof window & { __governanceSentTransactions?: Array<{ to?: string }> }
+  ).__governanceSentTransactions ?? [])
+  expect(sentTransactions).toHaveLength(1)
+  expect(sentTransactions[0]?.to?.toLowerCase()).toBe(G_TOKEN_CELO_ADDRESS.toLowerCase())
+})
+
+test('real adapter lets any wallet register for Alignment at the contract minimum stake', async ({
+  page,
+}) => {
+  logRuntimeDiagnostics(page)
+  await page.clock.install({ time: MOCK_NOW_SECONDS * 1000 })
+  await installInjectedProvider(page)
+  await installGovernanceRuntimeMocks(page, {
+    initialMemberStatus: 0,
+    memberStatusAfterReceipt: 1,
+    memberHouse: 1,
+  })
+  await gotoStory(page, 'qa-governancewidget-runtime-fixtures--real-adapter-mocked-runtime')
+
+  await submitAlignmentRegistration(page)
+
+  await expect(page.getByTestId('GovernanceWidget-pending-alignment')).toBeVisible()
+  const sentTransactions = await page.evaluate(() => (
+    window as typeof window & { __governanceSentTransactions?: Array<{ data?: Hex; to?: string }> }
+  ).__governanceSentTransactions ?? [])
+  expect(sentTransactions).toHaveLength(1)
+  expect(sentTransactions[0]?.to?.toLowerCase()).toBe(G_TOKEN_CELO_ADDRESS.toLowerCase())
+
+  const transactionData = sentTransactions[0]?.data
+  expect(transactionData).toBeTruthy()
+  const transfer = decodeFunctionData({ abi: G_TOKEN_ABI, data: transactionData as Hex })
+  expect(transfer.functionName).toBe('transferAndCall')
+  expect(transfer.args[0].toLowerCase()).toBe(MOCK_HOUSES.toLowerCase())
+  expect(transfer.args[1]).toBe(1_000n * 10n ** 18n)
+  const [house] = decodeAbiParameters(
+    [
+      { type: 'uint8' },
+      { type: 'string' },
+      { type: 'string' },
+      { type: 'string' },
+      { type: 'string' },
+      { type: 'string' },
+    ],
+    transfer.args[2],
+  )
+  expect(house).toBe(1)
+})
+
+test('real adapter keeps registration in onboarding after a reverted receipt', async ({ page }) => {
+  logRuntimeDiagnostics(page)
+  await page.clock.install({ time: MOCK_NOW_SECONDS * 1000 })
+  await installInjectedProvider(page)
+  const runtimeMocks = await installGovernanceRuntimeMocks(page, {
+    initialMemberStatus: 0,
+    memberStatusAfterReceipt: 2,
+    receiptStatus: 'reverted',
+  })
+  await gotoStory(page, 'qa-governancewidget-runtime-fixtures--real-adapter-mocked-runtime')
+
+  await submitCitizenshipRegistration(page)
+
+  await expect(page.getByText('The governance contract rejected this action.').first()).toBeVisible()
+  await expect(page.getByTestId('GovernanceWidget-onboarding')).toBeVisible()
+  await expect(page.getByTestId('GovernanceWidget-dashboard')).toHaveCount(0)
+  expect(runtimeMocks.receiptRequestCount()).toBeGreaterThan(0)
+})
+
+test('real adapter surfaces registration rejection without requesting a receipt', async ({ page }) => {
+  logRuntimeDiagnostics(page)
+  await page.clock.install({ time: MOCK_NOW_SECONDS * 1000 })
+  await installInjectedProvider(page, { rejectTransactions: true })
+  const runtimeMocks = await installGovernanceRuntimeMocks(page, { initialMemberStatus: 0 })
+  await gotoStory(page, 'qa-governancewidget-runtime-fixtures--real-adapter-mocked-runtime')
+
+  await submitCitizenshipRegistration(page)
+
+  await expect(page.getByText('Transaction rejected in the wallet.').first()).toBeVisible()
+  await expect(page.getByTestId('GovernanceWidget-onboarding')).toBeVisible()
+  expect(runtimeMocks.receiptRequestCount()).toBe(0)
+})
+
+test('real adapter waits for a successful unstake receipt and refreshes to onboarding', async ({ page }) => {
+  logRuntimeDiagnostics(page)
+  await installInjectedProvider(page)
+  await installGovernanceRuntimeMocks(page, { clearMemberAfterReceipt: true })
+  await gotoStory(page, 'qa-governancewidget-runtime-fixtures--real-adapter-mocked-runtime')
+
+  await page.getByRole('button', { name: 'Unstake membership' }).click()
+  await expect(page.getByTestId('GovernanceWidget-lifecycle-notice')).toContainText(
+    'Membership unstaked successfully.',
+  )
+  await expect(page.getByTestId('GovernanceWidget-onboarding')).toBeVisible()
+  const sentTransactions = await page.evaluate(() => (
+    window as typeof window & { __governanceSentTransactions?: Array<{ to?: string }> }
+  ).__governanceSentTransactions ?? [])
+  expect(sentTransactions).toHaveLength(1)
+  expect(sentTransactions[0]?.to?.toLowerCase()).toBe(MOCK_HOUSES.toLowerCase())
+})
+
+test('real adapter keeps membership active after a reverted unstake receipt', async ({ page }) => {
+  logRuntimeDiagnostics(page)
+  await installInjectedProvider(page)
+  await installGovernanceRuntimeMocks(page, { receiptStatus: 'reverted', clearMemberAfterReceipt: true })
+  await gotoStory(page, 'qa-governancewidget-runtime-fixtures--real-adapter-mocked-runtime')
+
+  await page.getByRole('button', { name: 'Unstake membership' }).click()
+  await expect(page.getByText('The governance contract rejected this action.')).toBeVisible()
+  await expect(page.getByTestId('GovernanceWidget-dashboard')).toBeVisible()
+  await expect(page.getByTestId('GovernanceWidget-friendly-error')).toHaveCount(0)
+  await expect(page.getByTestId('GovernanceWidget-unstake')).toBeVisible()
+  await expect(page.getByTestId('GovernanceWidget-onboarding')).toHaveCount(0)
+})
+
+test('real adapter surfaces wallet rejection without waiting for a receipt', async ({ page }) => {
+  logRuntimeDiagnostics(page)
+  await installInjectedProvider(page, { rejectTransactions: true })
+  await installGovernanceRuntimeMocks(page)
+  await gotoStory(page, 'qa-governancewidget-runtime-fixtures--real-adapter-mocked-runtime')
+
+  await page.getByRole('button', { name: 'Unstake membership' }).click()
+  await expect(page.getByText('Transaction rejected in the wallet.')).toBeVisible()
+  await expect(page.getByTestId('GovernanceWidget-dashboard')).toBeVisible()
+  await expect(page.getByTestId('GovernanceWidget-friendly-error')).toHaveCount(0)
+  await expect(page.getByTestId('GovernanceWidget-unstake')).toBeVisible()
+})
+
+test('pending unstake cannot publish stale receipt state after the account changes', async ({ page }) => {
+  logRuntimeDiagnostics(page)
+  await page.clock.install({ time: MOCK_NOW_SECONDS * 1000 })
+  await installInjectedProvider(page)
+  const runtimeMocks = await installGovernanceRuntimeMocks(page, { clearMemberAfterReceipt: true })
+  runtimeMocks.pauseReceipts()
+  await gotoStory(page, 'qa-governancewidget-runtime-fixtures--real-adapter-mocked-runtime')
+
+  await page.getByRole('button', { name: 'Unstake membership' }).click()
+  await expect(page.getByText('Waiting for a successful Celo receipt').first()).toBeVisible()
+  await page.evaluate((nextAccount) => {
+    const runtimeWindow = window as typeof window & {
+      __switchGovernanceAccount?: (account: string) => void
+    }
+    runtimeWindow.__switchGovernanceAccount?.(nextAccount)
+  }, MOCK_SWITCHED_ACCOUNT)
+
+  await expect(page.getByTestId('GovernanceWidget-header')).toContainText('0x9999')
+  runtimeMocks.resumeReceipts()
+  await expect(page.getByTestId('GovernanceWidget-dashboard')).toBeVisible()
+  await expect(page.getByTestId('GovernanceWidget-lifecycle-notice')).toHaveCount(0)
+  await expect(page.getByTestId('GovernanceWidget-onboarding')).toHaveCount(0)
+})
+
+test('vote submission is single-flight and ignores a stale receipt after account change', async ({ page }) => {
+  logRuntimeDiagnostics(page)
+  await page.clock.install({ time: MOCK_NOW_SECONDS * 1000 })
+  await installInjectedProvider(page)
+  const runtimeMocks = await installGovernanceRuntimeMocks(page)
+  runtimeMocks.pauseReceipts()
+  await gotoStory(page, 'qa-governancewidget-runtime-fixtures--real-adapter-mocked-runtime')
+
+  await page.getByTestId('GovernanceWidget-active-governance').click()
+  await expect(page.getByTestId('GovernanceWidget-vote-detail')).toBeVisible()
+  await page.getByRole('textbox').fill('10000')
+  const submitButton = page.getByRole('button', { name: 'Submit Allocation Vote' })
+  await expect(submitButton).toBeEnabled()
+  await submitButton.evaluate((button) => {
+    button.dispatchEvent(new MouseEvent('click', { bubbles: true }))
+    button.dispatchEvent(new MouseEvent('click', { bubbles: true }))
   })
+
+  await expect(page.getByText('Vote submitted. Waiting for confirmation').first()).toBeVisible()
+  await expect(submitButton).toBeDisabled()
+  await expect.poll(async () => page.evaluate(() => (
+    window as typeof window & { __governanceSentTransactions?: unknown[] }
+  ).__governanceSentTransactions?.length ?? 0)).toBe(1)
+
+  await page.evaluate((nextAccount) => {
+    const runtimeWindow = window as typeof window & {
+      __switchGovernanceAccount?: (account: string) => void
+    }
+    runtimeWindow.__switchGovernanceAccount?.(nextAccount)
+  }, MOCK_SWITCHED_ACCOUNT)
+  await expect(page.getByTestId('GovernanceWidget-header')).toContainText('0x9999')
+  runtimeMocks.resumeReceipts()
+
+  await expect(page.getByTestId('GovernanceWidget-dashboard')).toBeVisible()
+  await expect(page.getByTestId('GovernanceWidget-vote-detail')).toHaveCount(0)
+  await expect(page.getByText('Vote confirmed on Celo.')).toHaveCount(0)
+})
+
+test('real adapter clears account-scoped governance state while a new wallet loads', async ({ page }) => {
+  logRuntimeDiagnostics(page)
+  await installInjectedProvider(page)
+  const runtimeMocks = await installGovernanceRuntimeMocks(page)
+  await gotoStory(page, 'qa-governancewidget-runtime-fixtures--real-adapter-mocked-runtime')
+  await expect(page.getByTestId('GovernanceWidget-member-footer')).toBeVisible()
+
+  runtimeMocks.pauseReads()
+  try {
+    await page.evaluate((nextAccount) => {
+      const runtimeWindow = window as typeof window & {
+        __switchGovernanceAccount?: (account: string) => void
+      }
+      runtimeWindow.__switchGovernanceAccount?.(nextAccount)
+    }, MOCK_SWITCHED_ACCOUNT)
+
+    await expect(page.getByTestId('GovernanceWidget-header')).toContainText('0x9999')
+    await expect(page.getByTestId('GovernanceWidget-loading')).toBeVisible()
+    await expect(page.getByTestId('GovernanceWidget-member-footer')).toHaveCount(0)
+    await expect(page.getByTestId('GovernanceWidget-unstake')).toHaveCount(0)
+  } finally {
+    runtimeMocks.resumeReads()
+  }
+
+  await expect(page.getByTestId('GovernanceWidget-member-footer')).toBeVisible()
+  await expect(page.getByTestId('GovernanceWidget-unstake')).toBeVisible()
 })
diff --git a/tests/widgets/governance-widget/test-results/gw-01-impact-light.png b/tests/widgets/governance-widget/test-results/gw-01-impact-light.png
index b0e06348..a8b4b7db 100644
Binary files a/tests/widgets/governance-widget/test-results/gw-01-impact-light.png and b/tests/widgets/governance-widget/test-results/gw-01-impact-light.png differ
diff --git a/tests/widgets/governance-widget/test-results/gw-02-impact-dark-mobile-disabled.png b/tests/widgets/governance-widget/test-results/gw-02-impact-dark-mobile-disabled.png
index c710d53a..d83c6365 100644
Binary files a/tests/widgets/governance-widget/test-results/gw-02-impact-dark-mobile-disabled.png and b/tests/widgets/governance-widget/test-results/gw-02-impact-dark-mobile-disabled.png differ
diff --git a/tests/widgets/governance-widget/test-results/gw-03-balance-variants-light.png b/tests/widgets/governance-widget/test-results/gw-03-balance-variants-light.png
index 05958741..56d73504 100644
Binary files a/tests/widgets/governance-widget/test-results/gw-03-balance-variants-light.png and b/tests/widgets/governance-widget/test-results/gw-03-balance-variants-light.png differ
diff --git a/tests/widgets/governance-widget/test-results/gw-04-balance-dark-compact.png b/tests/widgets/governance-widget/test-results/gw-04-balance-dark-compact.png
index 96d19dba..b4829237 100644
Binary files a/tests/widgets/governance-widget/test-results/gw-04-balance-dark-compact.png and b/tests/widgets/governance-widget/test-results/gw-04-balance-dark-compact.png differ
diff --git a/tests/widgets/governance-widget/test-results/gw-05-alignment-default-light.png b/tests/widgets/governance-widget/test-results/gw-05-alignment-default-light.png
index 0553cfef..d5a5885b 100644
Binary files a/tests/widgets/governance-widget/test-results/gw-05-alignment-default-light.png and b/tests/widgets/governance-widget/test-results/gw-05-alignment-default-light.png differ
diff --git a/tests/widgets/governance-widget/test-results/gw-06-alignment-dark-long-options.png b/tests/widgets/governance-widget/test-results/gw-06-alignment-dark-long-options.png
index 09abd65e..74a19b34 100644
Binary files a/tests/widgets/governance-widget/test-results/gw-06-alignment-dark-long-options.png and b/tests/widgets/governance-widget/test-results/gw-06-alignment-dark-long-options.png differ
diff --git a/tests/widgets/governance-widget/test-results/gw-07-optimistic-high-quorum-light.png b/tests/widgets/governance-widget/test-results/gw-07-optimistic-high-quorum-light.png
index 227c775c..d5463aae 100644
Binary files a/tests/widgets/governance-widget/test-results/gw-07-optimistic-high-quorum-light.png and b/tests/widgets/governance-widget/test-results/gw-07-optimistic-high-quorum-light.png differ
diff --git a/tests/widgets/governance-widget/test-results/gw-08-optimistic-dark-low-quorum-mixed.png b/tests/widgets/governance-widget/test-results/gw-08-optimistic-dark-low-quorum-mixed.png
index e4df3e64..6fbe9dbe 100644
Binary files a/tests/widgets/governance-widget/test-results/gw-08-optimistic-dark-low-quorum-mixed.png and b/tests/widgets/governance-widget/test-results/gw-08-optimistic-dark-low-quorum-mixed.png differ
diff --git a/tests/widgets/governance-widget/test-results/gw-09-funding-distribution-light.png b/tests/widgets/governance-widget/test-results/gw-09-funding-distribution-light.png
index a0f93b9a..ea52af02 100644
Binary files a/tests/widgets/governance-widget/test-results/gw-09-funding-distribution-light.png and b/tests/widgets/governance-widget/test-results/gw-09-funding-distribution-light.png differ
diff --git a/tests/widgets/governance-widget/test-results/gw-10-funding-distribution-dark-populated.png b/tests/widgets/governance-widget/test-results/gw-10-funding-distribution-dark-populated.png
index afcd335c..0ae2d7a5 100644
Binary files a/tests/widgets/governance-widget/test-results/gw-10-funding-distribution-dark-populated.png and b/tests/widgets/governance-widget/test-results/gw-10-funding-distribution-dark-populated.png differ
diff --git a/tests/widgets/governance-widget/test-results/gw-11-funding-distribution-empty-dark-mobile.png b/tests/widgets/governance-widget/test-results/gw-11-funding-distribution-empty-dark-mobile.png
index d4d2ba4c..ae984688 100644
Binary files a/tests/widgets/governance-widget/test-results/gw-11-funding-distribution-empty-dark-mobile.png and b/tests/widgets/governance-widget/test-results/gw-11-funding-distribution-empty-dark-mobile.png differ
diff --git a/tests/widgets/governance-widget/test-results/gw-12-interaction-alignment.png b/tests/widgets/governance-widget/test-results/gw-12-interaction-alignment.png
index 0553cfef..d5a5885b 100644
Binary files a/tests/widgets/governance-widget/test-results/gw-12-interaction-alignment.png and b/tests/widgets/governance-widget/test-results/gw-12-interaction-alignment.png differ
diff --git a/tests/widgets/governance-widget/test-results/gw-13-impact-light-component-override.png b/tests/widgets/governance-widget/test-results/gw-13-impact-light-component-override.png
index 61261404..4a38ddde 100644
Binary files a/tests/widgets/governance-widget/test-results/gw-13-impact-light-component-override.png and b/tests/widgets/governance-widget/test-results/gw-13-impact-light-component-override.png differ
diff --git a/tests/widgets/governance-widget/test-results/gwo-01-welcome-verified.png b/tests/widgets/governance-widget/test-results/gwo-01-welcome-verified.png
index 49267df7..7d792444 100644
Binary files a/tests/widgets/governance-widget/test-results/gwo-01-welcome-verified.png and b/tests/widgets/governance-widget/test-results/gwo-01-welcome-verified.png differ
diff --git a/tests/widgets/governance-widget/test-results/gwo-02-house-selection.png b/tests/widgets/governance-widget/test-results/gwo-02-house-selection.png
index 717e9700..b4605433 100644
Binary files a/tests/widgets/governance-widget/test-results/gwo-02-house-selection.png and b/tests/widgets/governance-widget/test-results/gwo-02-house-selection.png differ
diff --git a/tests/widgets/governance-widget/test-results/gwo-03-profile-alignment.png b/tests/widgets/governance-widget/test-results/gwo-03-profile-alignment.png
index 884309c0..91e55843 100644
Binary files a/tests/widgets/governance-widget/test-results/gwo-03-profile-alignment.png and b/tests/widgets/governance-widget/test-results/gwo-03-profile-alignment.png differ
diff --git a/tests/widgets/governance-widget/test-results/gwo-04-stake-progress-active.png b/tests/widgets/governance-widget/test-results/gwo-04-stake-progress-active.png
index b7c1711c..16bc8bbc 100644
Binary files a/tests/widgets/governance-widget/test-results/gwo-04-stake-progress-active.png and b/tests/widgets/governance-widget/test-results/gwo-04-stake-progress-active.png differ
diff --git a/tests/widgets/governance-widget/test-results/gwo-05-success.png b/tests/widgets/governance-widget/test-results/gwo-05-success.png
index a9b5deea..a60cce7e 100644
Binary files a/tests/widgets/governance-widget/test-results/gwo-05-success.png and b/tests/widgets/governance-widget/test-results/gwo-05-success.png differ
diff --git a/tests/widgets/governance-widget/test-results/gwo-06-welcome-unverified.png b/tests/widgets/governance-widget/test-results/gwo-06-welcome-unverified.png
index 87d862be..647bb8a2 100644
Binary files a/tests/widgets/governance-widget/test-results/gwo-06-welcome-unverified.png and b/tests/widgets/governance-widget/test-results/gwo-06-welcome-unverified.png differ
diff --git a/tests/widgets/governance-widget/test-results/gwo-07-house-selection-standalone.png b/tests/widgets/governance-widget/test-results/gwo-07-house-selection-standalone.png
index b8282c99..509655ba 100644
Binary files a/tests/widgets/governance-widget/test-results/gwo-07-house-selection-standalone.png and b/tests/widgets/governance-widget/test-results/gwo-07-house-selection-standalone.png differ
diff --git a/tests/widgets/governance-widget/test-results/gwo-08-profile-citizenship-ready.png b/tests/widgets/governance-widget/test-results/gwo-08-profile-citizenship-ready.png
index 9c98c90a..85161ca7 100644
Binary files a/tests/widgets/governance-widget/test-results/gwo-08-profile-citizenship-ready.png and b/tests/widgets/governance-widget/test-results/gwo-08-profile-citizenship-ready.png differ
diff --git a/tests/widgets/governance-widget/test-results/gwo-09-profile-alignment-error.png b/tests/widgets/governance-widget/test-results/gwo-09-profile-alignment-error.png
index 981a7e1d..b9242eeb 100644
Binary files a/tests/widgets/governance-widget/test-results/gwo-09-profile-alignment-error.png and b/tests/widgets/governance-widget/test-results/gwo-09-profile-alignment-error.png differ
diff --git a/tests/widgets/governance-widget/test-results/gwo-10-stake-progress-failed.png b/tests/widgets/governance-widget/test-results/gwo-10-stake-progress-failed.png
index cfea67ad..4ca1510d 100644
Binary files a/tests/widgets/governance-widget/test-results/gwo-10-stake-progress-failed.png and b/tests/widgets/governance-widget/test-results/gwo-10-stake-progress-failed.png differ
diff --git a/tests/widgets/governance-widget/test-results/gwo-11-success-standalone.png b/tests/widgets/governance-widget/test-results/gwo-11-success-standalone.png
index a9b5deea..a60cce7e 100644
Binary files a/tests/widgets/governance-widget/test-results/gwo-11-success-standalone.png and b/tests/widgets/governance-widget/test-results/gwo-11-success-standalone.png differ
diff --git a/tests/widgets/governance-widget/test-results/gwr-01-disconnected-dashboard.png b/tests/widgets/governance-widget/test-results/gwr-01-disconnected-dashboard.png
index 69f5834a..d5eb405a 100644
Binary files a/tests/widgets/governance-widget/test-results/gwr-01-disconnected-dashboard.png and b/tests/widgets/governance-widget/test-results/gwr-01-disconnected-dashboard.png differ
diff --git a/tests/widgets/governance-widget/test-results/gwr-02-loading-connected.png b/tests/widgets/governance-widget/test-results/gwr-02-loading-connected.png
index bda2ffd5..8f285f80 100644
Binary files a/tests/widgets/governance-widget/test-results/gwr-02-loading-connected.png and b/tests/widgets/governance-widget/test-results/gwr-02-loading-connected.png differ
diff --git a/tests/widgets/governance-widget/test-results/gwr-03-onboarding-hoa-unavailable.png b/tests/widgets/governance-widget/test-results/gwr-03-onboarding-hoa-unavailable.png
deleted file mode 100644
index a2971274..00000000
Binary files a/tests/widgets/governance-widget/test-results/gwr-03-onboarding-hoa-unavailable.png and /dev/null differ
diff --git a/tests/widgets/governance-widget/test-results/gwr-03-onboarding-house-selection.png b/tests/widgets/governance-widget/test-results/gwr-03-onboarding-house-selection.png
new file mode 100644
index 00000000..0fa9a6f9
Binary files /dev/null and b/tests/widgets/governance-widget/test-results/gwr-03-onboarding-house-selection.png differ
diff --git a/tests/widgets/governance-widget/test-results/gwr-04-pending-alignment.png b/tests/widgets/governance-widget/test-results/gwr-04-pending-alignment.png
index fdc95b21..cc6a0ed4 100644
Binary files a/tests/widgets/governance-widget/test-results/gwr-04-pending-alignment.png and b/tests/widgets/governance-widget/test-results/gwr-04-pending-alignment.png differ
diff --git a/tests/widgets/governance-widget/test-results/gwr-05-active-citizenship.png b/tests/widgets/governance-widget/test-results/gwr-05-active-citizenship.png
index 67becba8..5ebff011 100644
Binary files a/tests/widgets/governance-widget/test-results/gwr-05-active-citizenship.png and b/tests/widgets/governance-widget/test-results/gwr-05-active-citizenship.png differ
diff --git a/tests/widgets/governance-widget/test-results/gwr-06-active-alignment-injected.png b/tests/widgets/governance-widget/test-results/gwr-06-active-alignment-injected.png
index f69223e8..71c574bd 100644
Binary files a/tests/widgets/governance-widget/test-results/gwr-06-active-alignment-injected.png and b/tests/widgets/governance-widget/test-results/gwr-06-active-alignment-injected.png differ
diff --git a/tests/widgets/governance-widget/test-results/gwr-07-vote-detail-open.png b/tests/widgets/governance-widget/test-results/gwr-07-vote-detail-open.png
index 717fe318..4615c16a 100644
Binary files a/tests/widgets/governance-widget/test-results/gwr-07-vote-detail-open.png and b/tests/widgets/governance-widget/test-results/gwr-07-vote-detail-open.png differ
diff --git a/tests/widgets/governance-widget/test-results/gwr-08-already-voted.png b/tests/widgets/governance-widget/test-results/gwr-08-already-voted.png
index 810418ba..bfb1f0aa 100644
Binary files a/tests/widgets/governance-widget/test-results/gwr-08-already-voted.png and b/tests/widgets/governance-widget/test-results/gwr-08-already-voted.png differ
diff --git a/tests/widgets/governance-widget/test-results/gwr-09-vote-closed-executed.png b/tests/widgets/governance-widget/test-results/gwr-09-vote-closed-executed.png
index 610c0009..7fc828ee 100644
Binary files a/tests/widgets/governance-widget/test-results/gwr-09-vote-closed-executed.png and b/tests/widgets/governance-widget/test-results/gwr-09-vote-closed-executed.png differ
diff --git a/tests/widgets/governance-widget/test-results/gwr-10-empty-recipients.png b/tests/widgets/governance-widget/test-results/gwr-10-empty-recipients.png
index d8391341..96dc97d5 100644
Binary files a/tests/widgets/governance-widget/test-results/gwr-10-empty-recipients.png and b/tests/widgets/governance-widget/test-results/gwr-10-empty-recipients.png differ
diff --git a/tests/widgets/governance-widget/test-results/gwr-11-pool-unavailable-mocked.png b/tests/widgets/governance-widget/test-results/gwr-11-pool-unavailable-mocked.png
index 7dca50a9..4a6e50cc 100644
Binary files a/tests/widgets/governance-widget/test-results/gwr-11-pool-unavailable-mocked.png and b/tests/widgets/governance-widget/test-results/gwr-11-pool-unavailable-mocked.png differ
diff --git a/tests/widgets/governance-widget/test-results/gwr-12-unsupported-chain.png b/tests/widgets/governance-widget/test-results/gwr-12-unsupported-chain.png
index 04ca4525..8a9a3d19 100644
Binary files a/tests/widgets/governance-widget/test-results/gwr-12-unsupported-chain.png and b/tests/widgets/governance-widget/test-results/gwr-12-unsupported-chain.png differ
diff --git a/tests/widgets/governance-widget/test-results/gwr-13-restake-required.png b/tests/widgets/governance-widget/test-results/gwr-13-restake-required.png
deleted file mode 100644
index cf81d95c..00000000
Binary files a/tests/widgets/governance-widget/test-results/gwr-13-restake-required.png and /dev/null differ
diff --git a/tests/widgets/governance-widget/test-results/gwr-13-unstake-ready.png b/tests/widgets/governance-widget/test-results/gwr-13-unstake-ready.png
new file mode 100644
index 00000000..3c225716
Binary files /dev/null and b/tests/widgets/governance-widget/test-results/gwr-13-unstake-ready.png differ
diff --git a/tests/widgets/governance-widget/test-results/gwr-14-friendly-contract-error.png b/tests/widgets/governance-widget/test-results/gwr-14-friendly-contract-error.png
index 7bf9a75c..5f1e2b9b 100644
Binary files a/tests/widgets/governance-widget/test-results/gwr-14-friendly-contract-error.png and b/tests/widgets/governance-widget/test-results/gwr-14-friendly-contract-error.png differ
diff --git a/tests/widgets/governance-widget/test-results/gwr-15-both-houses-available.png b/tests/widgets/governance-widget/test-results/gwr-15-both-houses-available.png
new file mode 100644
index 00000000..6109c400
Binary files /dev/null and b/tests/widgets/governance-widget/test-results/gwr-15-both-houses-available.png differ
diff --git a/tests/widgets/governance-widget/test-results/gwr-15-hoa-greyed-out.png b/tests/widgets/governance-widget/test-results/gwr-15-hoa-greyed-out.png
deleted file mode 100644
index b423bc59..00000000
Binary files a/tests/widgets/governance-widget/test-results/gwr-15-hoa-greyed-out.png and /dev/null differ
diff --git a/tests/widgets/governance-widget/test-results/gwr-16-unstake-wallet-confirmation.png b/tests/widgets/governance-widget/test-results/gwr-16-unstake-wallet-confirmation.png
new file mode 100644
index 00000000..b526261f
Binary files /dev/null and b/tests/widgets/governance-widget/test-results/gwr-16-unstake-wallet-confirmation.png differ
diff --git a/tests/widgets/governance-widget/test-results/gwr-17-unstake-submitted.png b/tests/widgets/governance-widget/test-results/gwr-17-unstake-submitted.png
new file mode 100644
index 00000000..54789c6a
Binary files /dev/null and b/tests/widgets/governance-widget/test-results/gwr-17-unstake-submitted.png differ
diff --git a/tests/widgets/governance-widget/test-results/gwr-18-unstake-rejected.png b/tests/widgets/governance-widget/test-results/gwr-18-unstake-rejected.png
new file mode 100644
index 00000000..8f855b9e
Binary files /dev/null and b/tests/widgets/governance-widget/test-results/gwr-18-unstake-rejected.png differ
diff --git a/tests/widgets/governance-widget/test-results/gwr-19-unstaked-onboarding.png b/tests/widgets/governance-widget/test-results/gwr-19-unstaked-onboarding.png
new file mode 100644
index 00000000..7f0fec2b
Binary files /dev/null and b/tests/widgets/governance-widget/test-results/gwr-19-unstaked-onboarding.png differ
diff --git a/tests/widgets/governance-widget/test-results/gwr-20-revoked.png b/tests/widgets/governance-widget/test-results/gwr-20-revoked.png
new file mode 100644
index 00000000..23869fee
Binary files /dev/null and b/tests/widgets/governance-widget/test-results/gwr-20-revoked.png differ
diff --git a/tests/widgets/governance-widget/test-results/gwr-21-real-adapter-mocked-runtime.png b/tests/widgets/governance-widget/test-results/gwr-21-real-adapter-mocked-runtime.png
new file mode 100644
index 00000000..0dd91b51
Binary files /dev/null and b/tests/widgets/governance-widget/test-results/gwr-21-real-adapter-mocked-runtime.png differ
diff --git a/tests/widgets/governance-widget/test-results/gwr-22-upcoming-vote.png b/tests/widgets/governance-widget/test-results/gwr-22-upcoming-vote.png
new file mode 100644
index 00000000..7ee394aa
Binary files /dev/null and b/tests/widgets/governance-widget/test-results/gwr-22-upcoming-vote.png differ
diff --git a/tests/widgets/governance-widget/test-results/gwr-23-unstake-reverted.png b/tests/widgets/governance-widget/test-results/gwr-23-unstake-reverted.png
new file mode 100644
index 00000000..9ae82118
Binary files /dev/null and b/tests/widgets/governance-widget/test-results/gwr-23-unstake-reverted.png differ