Production polish: i18n shelved, PWA icons, SEO/GEO cleanup, UX fixes

Big-picture changes since 01be8e7:

New routes — /trump /btc /kol /trades /analytics /archive plus four
SEO landing pages (/methodology /glossary /case-studies /contact),
all served under /[locale]. Each has dedicated metadata + JSON-LD.

KOL page (new) — DigestWidget + OnchainWidget + TalkVsTradesWidget,
filter by handle/ticker, click-through to per-post detail with the
original AI-extracted ticker/conviction/quote.

BTC page (new) — tabbed: macro-bottom (AHR999 + 200WMA + Pi Cycle)
and funding-rate reversal, with live sparkline + threshold bands.

Telegram card on Settings — wallet-link code generation, status,
disconnect. Preferences moved into the bot itself (/trump /btc etc.)
so the card stays minimal.

SignalMonitor (new) — ETH/LINK Bollinger breakout monitor in its own
component, shares the singleton WsProvider so no second WS opens.

WS singleton refactor (lib/wsContext) — shared WsProvider + useWsSubscribe
hook. Cleanup now actively closes the socket on unmount; previously the
local `ws` couldn't be reached from cleanup and leaked one connection
per StrictMode remount.

OpenPositions polling no longer pops MetaMask in the background —
splits into load('first') for user-initiated and load('poll') that
uses getCachedViewEnvelope without signing.

i18n shelved — proxy.ts (Next 16 middleware rename) wires next-intl
but only Navbar + layout footer have translations. Rest of UI used
isZh ternary scattered across 28 files. All `const isZh = locale === 'zh'`
flipped to `const isZh = false` so every site renders English; Chinese
branches kept as dead code so revival is one regex away.
LanguageSwitch hidden but file kept. zh-CN hreflang removed from
metadata + sitemap to avoid duplicate-content penalties.

Wallet error handling — lib/walletError.ts: isUserRejection walks EIP-1193
code 4001 + .cause chain; previous string-match for "reject"/"denied"
broke for users running MetaMask in non-English UIs. 12 call sites
migrated across 5 components.

PWA icons — app/icon.tsx + app/apple-icon.tsx render the brand "α" via
Next's ImageResponse so no static PNG asset is required. manifest.ts
references /icon and /apple-icon dynamic routes.

OG image + sitemap + robots — dynamic 1200×630 OG card; robots blocks
both /en/settings and /zh/settings; sitemap only emits /en routes;
JSON-LD covers SoftwareApplication + Organization + 10-Q FAQPage.

Landing page polish — Launch Dashboard button stripped of magnetic
hover + shimmer + lift + glow expansion (multiple users found it busy);
hero scramble alphabet swapped to alphanumeric (was block characters);
"15 KOL feeds" copy updated to 19 in 5 places.

PostCards source icons — new entries for btc_bottom_reversal,
funding_reversal, kol_divergence so they no longer fall through to
the generic "first letter" fallback.

Archive page filter — excludes funding_reversal + kol_divergence
(previously only excluded truth + btc_bottom_reversal so new live
signals leaked into the legacy archive).

Cache + skeleton loading — lib/cache.ts SWR module with per-key TTL,
applied across the major pages so navigation feels instant.

SignConfirmSheet — 4 hardcoded Chinese strings translated to English
(English users were seeing zh-only "需要钱包签名" etc).

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

lib/wsContext.tsx

@@ -0,0 +1,110 @@
+'use client'
+
+/**
+ * Singleton WebSocket provider.
+ *
+ * The entire app shares ONE connection to /ws/prices. Components subscribe
+ * to specific message types via `useWsSubscribe` — no component owns the socket.
+ *
+ * Why: previously DashboardClient (via usePriceSocket) and SignalMonitor each
+ * opened their own WebSocket, giving the server two connections per page load
+ * and causing each component to receive every broadcast twice.
+ */
+
+import {
+  createContext,
+  useContext,
+  useEffect,
+  useRef,
+  type ReactNode,
+} from 'react'
+
+type Handler = (msg: unknown) => void
+
+interface WsContextValue {
+  subscribe: (type: string, fn: Handler) => () => void
+}
+
+const WsContext = createContext<WsContextValue | null>(null)
+
+const WS_URL = process.env.NEXT_PUBLIC_WS_URL || 'ws://localhost:8000'
+
+export function WsProvider({ children }: { children: ReactNode }) {
+  // Stable map: message-type → set of handlers. Never replaced, only mutated.
+  const subs = useRef<Map<string, Set<Handler>>>(new Map())
+
+  useEffect(() => {
+    let dead = false
+    let retryTimer: ReturnType<typeof setTimeout> | null = null
+    // Hold the current socket at useEffect scope so cleanup can close it.
+    // Previously `ws` lived inside connect() and cleanup couldn't reach it,
+    // leaking one connection per StrictMode remount and one per [locale]
+    // layout swap (which remounts WsProvider).
+    let socket: WebSocket | null = null
+
+    function connect() {
+      if (dead) return
+      socket = new WebSocket(`${WS_URL}/ws/prices`)
+      const ws = socket   // local alias for handler closures
+
+      ws.onmessage = (e) => {
+        try {
+          const msg = JSON.parse(e.data) as { type?: string }
+          const t = msg.type ?? '__unknown__'
+          subs.current.get(t)?.forEach((fn) => fn(msg))
+        } catch {
+          // ignore malformed frames
+        }
+      }
+
+      ws.onclose = () => {
+        if (!dead) retryTimer = setTimeout(connect, 3000)
+      }
+      ws.onerror = () => ws.close()
+    }
+
+    connect()
+    return () => {
+      dead = true
+      if (retryTimer) clearTimeout(retryTimer)
+      // Actively close any live socket so the OS-level connection releases
+      // immediately on unmount instead of waiting for the next server keepalive.
+      if (socket && socket.readyState <= WebSocket.OPEN) {
+        socket.onclose = null   // suppress the auto-reconnect we'd otherwise queue
+        socket.close()
+      }
+      socket = null
+    }
+  }, [])
+
+  function subscribe(type: string, fn: Handler): () => void {
+    if (!subs.current.has(type)) subs.current.set(type, new Set())
+    subs.current.get(type)!.add(fn)
+    return () => subs.current.get(type)?.delete(fn)
+  }
+
+  return <WsContext.Provider value={{ subscribe }}>{children}</WsContext.Provider>
+}
+
+/**
+ * Subscribe to a specific WebSocket message type from the shared connection.
+ *
+ * @param type    The `msg.type` string to listen for (e.g. 'price', 'new_post', 'funding_signal')
+ * @param handler Called with the full parsed message object on every matching frame.
+ *                Always receives the latest handler reference — no stale-closure issues.
+ *
+ * Usage:
+ *   useWsSubscribe('price', (msg) => { ... })
+ */
+export function useWsSubscribe(type: string, handler: Handler): void {
+  const ctx = useContext(WsContext)
+  // Keep a ref so the subscription closure never goes stale even if handler
+  // is an inline function that changes every render.
+  const handlerRef = useRef<Handler>(handler)
+  handlerRef.current = handler
+
+  useEffect(() => {
+    if (!ctx) return
+    return ctx.subscribe(type, (msg) => handlerRef.current(msg))
+  }, [ctx, type]) // type is stable in practice; ctx never changes
+}