feat(treasury): In DeFi — net worth by right, not token-in-wallet

Stock next to the flow: a new card reads every protocol position the
treasury owns directly from chain state — ERC-4626 vault shares held by
the treasury (convertToAssets of ITS balance, never totalAssets, which
is everyone's money), its SplitsWarehouse balances, its verified share
of undistributed non-vault split balances, and MOR staked in the Gnars
Builders subnet. The vault-fee-in-splits row REUSES the stake graph's
gnarsAccrued — one truth shared with the Sponsorship card.

Spec rules wired in: a failed read renders as a failure (amber), never
as 0; a legitimate zero renders as $0 with liquidity context; the
vault-shares zero carries its explanation (the treasury never deposits
— supporters do) so nobody 'fixes' it into rendering depositor money.
The Total KPI becomes wallet + DeFi with the split named beneath it,
and an incomplete DeFi read keeps the total as a labeled floor.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: sktbrd

messages/en/treasury.json

@@ -10,7 +10,9 @@
       "subnetEarnings": "Subnet Earnings",
       "acrossAssets": "across {count} assets",
       "auctionsSettled": "{count} auctions settled",
-      "morpheusClaims": "Morpheus · {count} claims"
+      "morpheusClaims": "Morpheus · {count} claims",
+      "walletVsDefi": "In wallet {wallet} · In DeFi {defi}",
+      "defiUnavailable": "DeFi positions unreadable — the total shows the wallet only"
     },
     "nftSection": {
       "title": "NFT Holdings",
@@ -116,5 +118,25 @@
     "accrualNote": "Fees materialize when someone interacts with a vault, not continuously — the figures can sit still for weeks, then jump all at once. An older small vault can carry more accrued fee than a big recent one.",
     "fromVaults": "Vault fee",
     "fromMor": "MOR rewards"
+  },
+  "defi": {
+    "title": "In DeFi",
+    "description": "Protocol positions the treasury owns by right",
+    "positions": {
+      "vaultShares": "Rider vault shares (Morpho)",
+      "feeInSplits": "Vault fee accrued in rider splits",
+      "warehouse": "Splits Warehouse balance",
+      "splitPending": "Undistributed split balances",
+      "subnetStake": "MOR staked in the Gnars subnet",
+      "vaultSharesZeroNote": "the treasury never deposits here — its right is the performance fee accruing in the splits"
+    },
+    "liquidity": {
+      "instant": "redeemable now — permissionless",
+      "proposal": "redeem via governance proposal",
+      "locked": "locked until {date}"
+    },
+    "readFailed": "read failed",
+    "total": "Total in DeFi",
+    "incomplete": "* one or more positions could not be read — the total is a floor, not the whole truth"
   }
 }

messages/pt-br/treasury.json

@@ -10,7 +10,9 @@
       "subnetEarnings": "Ganhos da Subnet",
       "acrossAssets": "em {count} ativos",
       "auctionsSettled": "{count} leilões concluídos",
-      "morpheusClaims": "Morpheus · {count} resgates"
+      "morpheusClaims": "Morpheus · {count} resgates",
+      "walletVsDefi": "Em carteira {wallet} · Em DeFi {defi}",
+      "defiUnavailable": "Posições DeFi ilegíveis — o total mostra só a carteira"
     },
     "nftSection": {
       "title": "Holdings de NFT",
@@ -116,5 +118,25 @@
     "accrualNote": "O rendimento materializa quando alguém interage com o vault, não de forma contínua — os números podem ficar parados por semanas e pular de uma vez. Um vault pequeno e antigo pode acumular mais que um grande e recente.",
     "fromVaults": "Taxa dos vaults",
     "fromMor": "Recompensas MOR"
+  },
+  "defi": {
+    "title": "Em DeFi",
+    "description": "Posições em protocolo que o tesouro detém por direito",
+    "positions": {
+      "vaultShares": "Shares dos vaults de rider (Morpho)",
+      "feeInSplits": "Fee de vault acumulada nos splits dos riders",
+      "warehouse": "Saldo no Splits Warehouse",
+      "splitPending": "Saldos não distribuídos nos splits",
+      "subnetStake": "MOR em stake no subnet da Gnars",
+      "vaultSharesZeroNote": "o tesouro não deposita nos vaults — o direito dele é a taxa de performance que acumula nos splits"
+    },
+    "liquidity": {
+      "instant": "resgatável já — permissionless",
+      "proposal": "resgate via proposta de governança",
+      "locked": "em lock até {date}"
+    },
+    "readFailed": "falha de leitura",
+    "total": "Total em DeFi",
+    "incomplete": "* uma ou mais posições não puderam ser lidas — o total é um piso, não a verdade inteira"
   }
 }

src/app/[locale]/treasury/page.tsx

@@ -12,6 +12,7 @@ import { SponsorshipYield } from "@/components/treasury/SponsorshipYield";
 import { SyncedBadge } from "@/components/treasury/SyncedBadge";
 import { TokenHoldings } from "@/components/treasury/TokenHoldings";
 import { TreasuryAllocation } from "@/components/treasury/TreasuryAllocation";
+import { TreasuryDefi } from "@/components/treasury/TreasuryDefi";
 import { TreasuryInflows } from "@/components/treasury/TreasuryInflows";
 import { TreasuryKpiRow } from "@/components/treasury/TreasuryKpiRow";
 import { DAO_ADDRESSES } from "@/lib/config";
@@ -135,6 +136,12 @@ export default async function TreasuryPage({ params }: { params: Promise<{ local
             <Suspense fallback={<TableSkeleton />}>
               <TokenHoldings treasuryAddress={DAO_ADDRESSES.treasury} />
             </Suspense>
+            {/* Stock, not flow: what the treasury owns by right in protocol
+                positions. Sits under Token Holdings ("in wallet") so the two
+                halves of the Total KPI are adjacent and reconcilable. */}
+            <Suspense fallback={<TableSkeleton />}>
+              <TreasuryDefi />
+            </Suspense>
           </div>
         </div>
 

src/components/treasury/TreasuryDefi.tsx

@@ -0,0 +1,96 @@
+import { getLocale, getTranslations } from "next-intl/server";
+import { Layers } from "lucide-react";
+import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card";
+import { formatFiatUsd } from "@/lib/i18n/fiat";
+import { toIntlLocale } from "@/lib/i18n/format";
+import { getBrlRateForRequest } from "@/services/exchange-rate";
+import { loadTreasuryDefi, type DefiLiquidity } from "@/services/treasury-defi";
+
+/**
+ * "In DeFi" — what the treasury owns by right in protocol positions, stock not
+ * flow. Every row is its own on-chain read; a failed read renders as a failure
+ * (amber), a legitimate zero renders as $0 — the two must never look alike.
+ * The vault-fee row is the stake graph's own `gnarsAccrued`, so this card and
+ * the Sponsorship card can never disagree about that number.
+ */
+export async function TreasuryDefi() {
+  const t = await getTranslations("treasury.defi");
+  const locale = await getLocale();
+  const [defi, brlRate] = await Promise.all([loadTreasuryDefi(), getBrlRateForRequest()]);
+
+  const fiat = (usd: number) => formatFiatUsd(usd, locale, brlRate);
+  const lockLabel = (liq: DefiLiquidity): string => {
+    if (liq.kind === "proposal") return t("liquidity.proposal");
+    if (liq.kind === "locked")
+      return t("liquidity.locked", {
+        date: new Date(liq.unlockAt * 1000).toLocaleDateString(toIntlLocale(locale), {
+          day: "2-digit",
+          month: "2-digit",
+        }),
+      });
+    return t("liquidity.instant");
+  };
+
+  return (
+    <Card className="gap-2">
+      <CardHeader>
+        <CardTitle className="flex items-center gap-2 text-sm font-medium">
+          <Layers className="size-4" /> {t("title")}
+        </CardTitle>
+        <CardDescription>{t("description")}</CardDescription>
+      </CardHeader>
+      <CardContent className="space-y-1">
+        <ul className="divide-y">
+          {defi.positions.map((p) => (
+            <li key={p.labelKey} className="flex items-baseline justify-between gap-3 py-2.5">
+              <div className="min-w-0">
+                <div className="text-[13px] font-medium">{t(`positions.${p.labelKey}`)}</div>
+                {/* Zero-by-design gets its explanation, not a redeem hint: the
+                    treasury never deposits into the vaults — supporters do —
+                    so a mute $0 here reads as a bug and invites the exact
+                    wrong "fix" (rendering totalAssets, i.e. everyone's money,
+                    as Gnars net worth). */}
+                <div className="text-[11px] text-muted-foreground">
+                  {p.labelKey === "vaultShares" && p.ok && p.usd === 0
+                    ? t("positions.vaultSharesZeroNote")
+                    : lockLabel(p.liquidity)}
+                </div>
+              </div>
+              <div className="shrink-0 text-right">
+                {p.ok ? (
+                  <>
+                    <span
+                      className={`font-mono text-sm tabular-nums ${p.usd === 0 ? "text-muted-foreground" : "font-semibold"}`}
+                    >
+                      {fiat(p.usd)}
+                    </span>
+                    {p.amount && (
+                      <div className="text-[11px] text-muted-foreground tabular-nums">
+                        {p.amount}
+                      </div>
+                    )}
+                  </>
+                ) : (
+                  <span className="text-xs font-medium text-amber-600 dark:text-amber-500">
+                    {t("readFailed")}
+                  </span>
+                )}
+              </div>
+            </li>
+          ))}
+        </ul>
+
+        <div className="flex items-baseline justify-between gap-2.5 border-t pt-3">
+          <span className="text-xs text-muted-foreground">{t("total")}</span>
+          <span className="font-mono text-sm font-semibold tabular-nums">
+            {fiat(defi.knownUsd)}
+            {!defi.complete && <span className="text-amber-600 dark:text-amber-500"> *</span>}
+          </span>
+        </div>
+        {!defi.complete && (
+          <p className="text-[11px] text-amber-600 dark:text-amber-500">{t("incomplete")}</p>
+        )}
+      </CardContent>
+    </Card>
+  );
+}

src/components/treasury/TreasuryKpiRow.tsx

@@ -6,6 +6,7 @@ import { formatFiatUsd } from "@/lib/i18n/fiat";
 import { fetchSettledAuctionCount } from "@/services/dao";
 import { getBrlRateForRequest } from "@/services/exchange-rate";
 import { loadTreasurySnapshot } from "@/services/treasury";
+import { loadTreasuryDefi } from "@/services/treasury-defi";
 import { loadSubnetEarnings } from "@/services/treasury-inflows";
 import { FiatFallbackNote } from "./FiatFallbackNote";
 import { KpiValue } from "./KpiValue";
@@ -56,13 +57,22 @@ function UsdcMark() {
 export async function TreasuryKpiRow() {
   const t = await getTranslations("treasury.page.kpis");
   const locale = await getLocale();
-  const [snapshot, subnet, auctionCount, brlRate] = await Promise.all([
+  const [snapshot, subnet, auctionCount, brlRate, defi] = await Promise.all([
     loadTreasurySnapshot(DAO_ADDRESSES.treasury).catch(() => null),
     loadSubnetEarnings(),
     fetchSettledAuctionCount(),
     getBrlRateForRequest(),
+    loadTreasuryDefi().catch(() => null),
   ]);
 
+  // Total = wallet + DeFi (net worth by right, the shared three-surface spec).
+  // A failed DeFi read keeps the wallet total but says so out loud — the sum
+  // of the KNOWN positions still counts (it is a floor, never an estimate).
+  const walletUsd = snapshot?.usdTotal ?? null;
+  const defiKnown = defi?.knownUsd ?? 0;
+  const totalUsd = walletUsd == null ? null : walletUsd + defiKnown;
+  const defiHealthy = defi != null && defi.complete;
+
   const cards: Array<{
     key: string;
     label: string;
@@ -76,9 +86,24 @@ export async function TreasuryKpiRow() {
       key: "total",
       label: t("totalValue"),
       accent: "--chart-5",
-      value: <KpiValue value={snapshot?.usdTotal ?? null} decimals={2} fiat brlRate={brlRate} />,
-      note: snapshot ? t("acrossAssets", { count: snapshot.assetCount }) : null,
-      extra: <FiatFallbackNote brlRate={brlRate} className="relative mt-1" />,
+      value: <KpiValue value={totalUsd} decimals={2} fiat brlRate={brlRate} />,
+      note:
+        walletUsd != null
+          ? t("walletVsDefi", {
+              wallet: formatFiatUsd(walletUsd, locale, brlRate),
+              defi: formatFiatUsd(defiKnown, locale, brlRate),
+            })
+          : null,
+      extra: (
+        <>
+          {!defiHealthy && (
+            <p className="relative mt-1 text-xs text-amber-600 dark:text-amber-500">
+              {t("defiUnavailable")}
+            </p>
+          )}
+          <FiatFallbackNote brlRate={brlRate} className="relative mt-1" />
+        </>
+      ),
       mark: (
         <Image
           src="/red_noggles.png"

src/services/treasury-defi.test.ts

@@ -0,0 +1,36 @@
+import { describe, expect, it } from "vitest";
+import { summarizeDefi, type DefiPosition } from "./treasury-defi";
+
+const ok = (usd: number): DefiPosition => ({
+  labelKey: "x",
+  liquidity: { kind: "instant" },
+  ok: true,
+  usd,
+});
+const failed: DefiPosition = { labelKey: "x", liquidity: { kind: "instant" }, ok: false };
+
+describe("summarizeDefi", () => {
+  it("sums known positions and reports complete when all reads succeeded", () => {
+    const s = summarizeDefi([ok(10), ok(0), ok(2.5)]);
+    expect(s.knownUsd).toBeCloseTo(12.5);
+    expect(s.complete).toBe(true);
+  });
+
+  it("a failed read never counts as zero silently — complete goes false", () => {
+    const s = summarizeDefi([ok(10), failed]);
+    expect(s.knownUsd).toBe(10);
+    expect(s.complete).toBe(false);
+  });
+
+  it("legitimate zeros keep complete true — zero is a fact, not a failure", () => {
+    const s = summarizeDefi([ok(0), ok(0)]);
+    expect(s.knownUsd).toBe(0);
+    expect(s.complete).toBe(true);
+  });
+
+  it("all-failed yields zero known and incomplete", () => {
+    const s = summarizeDefi([failed, failed]);
+    expect(s.knownUsd).toBe(0);
+    expect(s.complete).toBe(false);
+  });
+});