feat: surface AI analysis duration across gateway, backend, and FE

Adds per-message AI moderation analysis time (ai_analysis_duration_ms)
so operators can see how long the LLM took to moderate each message.

Gateway:
- messagesTable: new ai_analysis_duration_ms (bigint) column.
- AIAnalysisUpdate + buildAIAnalysisSet: carry analysisDurationMs through
  both single and bulk update paths.
- ai-analysis-worker: measure wall-clock time around runModerationAnalysis
  and attach it to every result in the batch.

Backend:
- Mirror schema column; messageMapper maps ai_analysis_duration_ms;
  moderation-types + MappedMessage expose it.

Frontend:
- message.ts type gains ai_analysis_duration_ms.
- AiBadge (messages view) shows 'status · 1.2s' when duration is present;
  analysis view badge mirrors the same formatting.

DB:
- scripts/add-ai-analysis-duration.sql (idempotent ADD COLUMN IF NOT EXISTS).

No behavior change for moderation logic; null until new gateway build
records values.

.hermes/plans/2026-08-13_gmw-frontend-greenfield.md

@@ -0,0 +1,418 @@
+# GMW Frontend — Greenfield Rebuild (Visual-System Overhaul + Custom UI + Motion/3D)
+
+> **For Hermes:** Execute with `subagent-driven-development` (one fresh subagent per task, two-stage review). Each task is 1–3 min, atomic, independently verifiable, committed after each. Reuse `src/lib/api/*`, `src/lib/ws/*`, `src/lib/types/*`, hooks verbatim. Never invent endpoints.
+
+**Goal:** Rebuild the GMW Discord-automod dashboard frontend from scratch — drop shadcn/ui + glass/teal/purple aesthetic entirely, replace with a custom, distinctive design system where every page has its own visual metaphor (no uniform bordered-card grid), and push the presentation layer with **Framer Motion (`motion`) choreography + signature Three.js scenes**. Re-integrate to the EXISTING backend API + WebSocket contract (do NOT touch the backend).
+
+**Architecture:** Next.js 16 App Router (SSR) + React 19 + TS strict + Tailwind v4. Keep the *plumbing* (data contract), rebuild the *skin + primitives + motion*. Each route = one self-contained `page.tsx` (server fetch + client view in the same file via a `"use client"` sibling export). Custom SVG charts (no recharts). Custom micro-primitives (no shadcn/base-ui). New token system in `globals.css`. **Motion:** `motion/react` app-wide for page transitions, spring micro-interactions, layout animation. **3D:** raw `three` (no react-three-fiber — leaner) in exactly TWO signature scenes, lazy-loaded client-only with graceful fallback. Deployed unchanged via existing flake + `gmw-proxy` nginx (`:4009` → Next `:4017`).
+
+**Tech Stack:** next@16, react@19, tailwindcss@4 (`@import "tailwindcss"`), `next/font/google` (Bricolage Grotesque + Inter + JetBrains Mono), `swr` (data revalidation), `lucide-react` (icons only), `motion` (Framer Motion successor — `motion/react`), `three` + `@types/three` (signature scenes only), `clsx` + `tailwind-merge`. **Removed:** `@shadcn/react`, `@base-ui/react`, `recharts`, `shadcn` CLI, `cmdk`, `sonner`, `react-day-picker`, `embla-carousel-react`, `react-resizable-panels`, `input-otp`, all 50 `components/ui/*`.
+
+---
+
+## 0. Design System (the creative core — read before coding)
+
+**Persona:** Controlled UX Designer + a tactical "ops console" voice. Material honesty: hierarchy via **scale/weight/tonal blocks**, NOT borders/shadows. Per `frontend-design` skill principle — spend the boldness in ONE signature place per page, keep the rest disciplined. Motion is choreography, not confetti: **one orchestrated moment per page**, everything else quiet.
+
+### Palette (warm, signal-driven — NO teal/cyan/purple/blue gradients)
+Light mode (`:root`):
+```
+--canvas:      oklch(0.96 0.012 80)    /* warm off-white, not cream */
+--surface:     oklch(0.92 0.014 80)    /* tonal block, replaces bordered card */
+--surface-2:   oklch(0.88 0.016 80)
+--ink:         oklch(0.22 0.02 70)     /* primary text */
+--ink-soft:    oklch(0.46 0.02 70)     /* secondary text */
+--hairline:    oklch(0.22 0.02 70 / 0.10)  /* structural rules ONLY, sparse */
+--signal:      oklch(0.78 0.17 125)    /* lime — OK / live / primary accent */
+--signal-ink:  oklch(0.20 0.03 70)     /* text ON signal */
+--amber:       oklch(0.80 0.15 70)     /* WARN */
+--vermilion:   oklch(0.62 0.21 25)     /* FLAGGED / destructive */
+--ring:        var(--signal)
+```
+Dark mode (`.dark`, default theme per `next-themes`):
+```
+--canvas:      oklch(0.13 0.015 70)    /* warm charcoal, not blue-black */
+--surface:     oklch(0.18 0.02 70)
+--surface-2:   oklch(0.23 0.022 70)
+--ink:         oklch(0.93 0.01 75)
+--ink-soft:    oklch(0.62 0.02 75)
+--hairline:    oklch(1 0 0 / 0.09)
+--signal:      oklch(0.88 0.18 125)
+--signal-ink:  oklch(0.18 0.03 70)
+--amber:       oklch(0.85 0.15 70)
+--vermilion:   oklch(0.68 0.21 25)
+```
+Three semantic signals reused everywhere: **lime = OK/live, amber = warn, vermilion = flag/danger**. This kills the purple-accent + teal-primary monotony.
+
+### Typography (3 roles, deliberate pairing — not "Inter everywhere")
+- **Display:** `Bricolage Grotesque` (700–800) — characterful grotesque for headers/big numbers.
+- **Body/UI:** `Inter` (400–600).
+- **Data/label:** `JetBrains Mono` (500/700) — all stats, timestamps, channel IDs, metrics.
+Load all three via `next/font/google` with CSS variables (keep current `--font-inter`/`--font-jetbrains-mono` names + add `--font-display`).
+
+### Layout & signature
+- **No `card` with border.** Use tonal `--surface` blocks with generous radius (`--r: 14px`) and internal padding; separate blocks with whitespace + sparse hairlines only where structurally meaningful.
+- **Signature element = "scan-tick":** a 1px animated pulse line (CSS keyframe `scan`) that marks every live/section header — NOT a card outline. Global canvas carries a faint warm dot-grid texture (low opacity) instead of the current bluish dotted radial-gradient.
+- **Nav = left "spine":** vertical rail of icon nodes joined by a hairline; active node gets a `--signal` dot + label reveal. Collapses to a bottom tab-bar < 768px (CSS only, no JS sidebar primitive).
+- **Header = "status bar":** connection state (WS dot), guild selector, live clock — mono font, reads like an instrument readout.
+
+## 0.1 Motion & 3D Layer (the "lebih kreatif" addition)
+
+### Motion rules (from `motion/react`)
+- **Page transitions:** one shared `RouteTransition` in `(dashboard)/layout.tsx` — `AnimatePresence mode="popLayout"` + `motion.div key={pathname}` (fade + 8px rise + slight blur-out, ~220ms, `easeOut`). Consistent everywhere, zero per-page boilerplate.
+- **Enter choreography (per page, ONE signature moment):** staggered rise-in for the hero/ticker group using `staggerChildren` variants; afterwards, quiet springs for hover/tap (`scale: 1.03` on interactive blocks, `whileTap` on buttons).
+- **Layout animation:** `layout` prop on list items (messages rows, recording rows, queue) so add/remove/filter reflows smoothly; `layoutId` for shared-element transitions (ticker → detail modal on dashboard).
+- **Live pulse:** `motion` drives the severity ticks / speaker rings with springs, not CSS `transition` alone.
+- **`useReducedMotion()`** (from `motion/react`) gates ALL heavy motion; CSS `@media (prefers-reduced-motion: reduce)` additionally kills `scan`/`spin-disc` keyframes. Accessibility floor, non-negotiable.
+- **No scroll-jacking, no marquee loops, no per-element confetti.** One moment per page. (`frontend-design` skill: "Satu momen orkestrasi biasanya lebih mengena daripada efek tersebar.")
+
+### 3D rules (raw `three`, no R3F — lean bundle)
+- Exactly **two** scenes, chosen because they carry real data meaning: **Dashboard hero** (`SignalField` — a particle field whose pulse density reflects live activity) and **Voice page** (`OrbField` — speakers as glowing orbs whose height/ring radius reacts to who is speaking). Everything else stays 2D/motion.
+- **Lazy + client-only:** `next/dynamic(() => import("./SignalField"), { ssr: false, loading: () => <StaticFallback/> })`. Three ships in its own chunk, loaded only on those two routes.
+- **WebGL guard:** if `!window.WebGLRenderingContext` or context creation fails → render the static SVG/CSS fallback (a stylized 2D version of the same visual). Never blank.
+- **Perf guardrails:** `dpr: [1, 1.75]`, `powerPreference: "high-performance"`, `antialias: true`; RAF loop paused on `document.hidden`; `dispose()` geometries/materials on unmount; particle count capped by `navigator.hardwareConcurrency` + viewport (`Math.min(900, w*h/2000)`).
+- **Style:** warm palette ONLY — signal-lime particles, amber/vermilion for flag/warn states; fog + soft additive blending for glow (no harsh white lights, no metallic PBR).
+- **Interactivity:** subtle pointer parallax (camera lerp toward cursor) + gentle idle rotation. No drag/drop, no raycasting menus.
+
+### Per-page metaphor (kills monotony — each page feels different)
+| Route | Metaphor | Signature visual | Motion / 3D |
+|---|---|---|---|
+| `/dashboard` | Live ops overview | **3D signal particle field** hero + asymmetric ticker blocks + radial moderation gauge | **3D SignalField** (reacts to activity), staggered ticker rise-in, gauge draws on mount |
+| `/messages` | Transcript | Left channel **timeline spine**; right = flowing message entries with left **severity tick** (no bordered cards); search = command palette | `layout` on message rows, spring severity ticks, palette types in |
+| `/voice` | Stage | **3D orb field** of speakers + equalizer rings; activity = horizontal **session ribbon** | **3D OrbField** (speaking → orb rises + ring pulses), session ribbon draws sequentially |
+| `/media` | Turntable | Rotating **disc** now-playing; queue = borderless list | CSS 3D disc spin (spring on play/pause), queue `layout` reflow, progress bar springs |
+| `/recordings` | Tape library | Rows with **waveform thumbnail** (custom SVG from duration) | Waveform bars spring on hover; new upload animates in (AnimatePresence) |
+| `/moderation` | Security log | Vertical **event flow** with status nodes (dot + line), not a table of cards | Nodes pulse on live action; timeline draws in sequence |
+| `/analysis` | Query console | Terminal-style search panel | Typing cursor + results stagger |
+
+---
+
+## 1. What to KEEP (reuse verbatim — correct + integrates to backend)
+- `src/lib/api/server.ts` — 11 server fetchers (`getDashboardStats`, `getActivity`, `getMediaStatus`, `getConfig`, `getModerationStats/Actions`, `getGuilds`, `getVoiceStatus`, `getRecordings`, `getMessages`). **No change.**
+- `src/lib/api/client.ts` — `apiRequest` + `ApiError`. **No change.**
+- `src/lib/ws/*` — `connection.ts`, `context.tsx`, `types.ts` (17 typed events: `message_created/updated/deleted/analyzed`, `voice_*`, `media_state`, `voice_pcm_data` binary). **No change.**
+- `src/lib/types/*` — all interfaces. **No change.**
+- `src/lib/format.ts`, `src/lib/utils.ts` (`cn`). **No change.**
+- `src/lib/navigation.ts` — `navItems`. Keep but extend icons/labels if needed.
+- Hooks: `src/hooks/*` (use-dashboard, use-media, use-messages, use-voice, use-moderation, use-recordings, use-guilds, use-config, use-chatbot-user, use-action, use-mobile), `src/lib/hooks/use-mounted.ts`. **Reuse** (verify no bad imports into deleted barrels).
+- Feature logic kept but **reskinned**: `src/components/media/music-player.tsx`, `src/components/voice/*`, `src/components/chatbot/*`, `src/components/messages/*`, `src/components/recordings/*`, `src/components/moderation/moderation-section.tsx`, `src/components/analysis/search-panel.tsx`, `src/components/dashboard/*` (charts → rewritten as custom SVG).
+
+## 2. What to DELETE
+- `src/components/ui/*` (all 50 shadcn primitives).
+- `components.json`, `@shadcn/react` + `@base-ui/react` + `shadcn` deps.
+- `recharts` (replace with custom SVG chart helpers in `src/components/charts/`).
+- `src/app/globals.css` → rewrite (no `@import "shadcn/tailwind.css"`, no `--color-primary` teal, no `.glass*`, no `.text-gradient`/`.gradient-border` teal/purple, no bluish body texture).
+- `src/components/layout/app-sidebar.tsx` (shadcn Sidebar) → replace with custom `Spine` nav.
+- All `page.tsx`+`view.tsx` pairs → merge into single `page.tsx` per route.
+
+## 3. What to BUILD (new)
+- New `globals.css` (tokens above + utilities + keyframes `scan`, `eq`, `fade-up`, `spin-disc`).
+- `src/components/primitives/` — minimal custom: `Button`, `Input`, `Select`, `Dialog`, `Tooltip`, `Badge`, `Progress`, `Avatar`, `Skeleton`, `Toast`, `Sheet`.
+- `src/components/motion/` — `RouteTransition.tsx`, `Stagger.tsx`, `variants.ts`.
+- `src/components/three/` — `SignalField.tsx`, `OrbField.tsx`, `WebGLGuard.tsx`, `StaticFallback.tsx`, `useThreeScene.ts`.
+- `src/components/charts/` — `Sparkline`, `AreaActivity`, `RadialGauge`, `SessionRibbon`, `Waveform`.
+- `src/components/layout/` — `Spine.tsx`, `StatusBar.tsx`, `ThemeToggle.tsx` (reskin).
+- 7 merged `page.tsx` files (one per route) implementing the metaphors above.
+- `src/app/layout.tsx` — root (fonts + ThemeProvider + Toaster), `src/app/(dashboard)/layout.tsx` — providers + Spine + StatusBar + RouteTransition + MiniPlayer + Chatbot, `src/app/page.tsx` → redirect `/dashboard`.
+
+---
+
+## 4. Target File & Folder Structure (authoritative)
+
+Everything below `services/frontend/src/` is the new tree. `REWRITE` replaces existing; `NEW` creates; `DELETE` removes. The `app/` route tree collapses `page.tsx`+`view.tsx` into single `page.tsx` files containing BOTH server fetch (default export) and client view (`"use client"` named export in same file).
+
+```
+services/frontend/
+├─ package.json                         REWRITE  (drop shadcn/base-ui/recharts; add motion, three, @types/three)
+├─ pnpm-workspace.yaml                  REWRITE  (onlyBuiltDependencies: keep build list minimal)
+├─ components.json                      DELETE   (shadcn registry config — no longer used)
+├─ next.config.ts                       KEEP     (output: standalone, trailingSlash, images.unoptimized)
+├─ tsconfig.json                        KEEP     (paths "@/*" → src/*, strict)
+├─ postcss.config.mjs                   KEEP     (@tailwindcss/postcss)
+├─ biome.json                           KEEP
+└─ src/
+   ├─ app/
+   │  ├─ layout.tsx                     REWRITE  (3 fonts + ThemeProvider + custom Toaster; rm sonner)
+   │  ├─ globals.css                    REWRITE  (new token system §0; rm glass/teal/purple)
+   │  ├─ page.tsx                       KEEP     (redirect → /dashboard/)
+   │  └─ (dashboard)/
+   │     ├─ layout.tsx                  REWRITE  (providers + Spine + StatusBar + RouteTransition + MiniPlayer + Chatbot; rm shadcn Sidebar)
+   │     ├─ dashboard/   page.tsx       REWRITE  (server fetch + <DashboardView/> client; 3D SignalField hero)
+   │     ├─ messages/    page.tsx       REWRITE  (server seeds + <MessagesView/>; spine + severity ticks)
+   │     ├─ voice/       page.tsx       REWRITE  (server seeds + <VoiceView/>; 3D OrbField hero)
+   │     ├─ media/       page.tsx       REWRITE  (server seeds + <MediaView/>; turntable disc)
+   │     ├─ recordings/  page.tsx       REWRITE  (server seeds + <RecordingsView/>; waveform rows)
+   │     ├─ moderation/  page.tsx       REWRITE  (server seeds + <ModerationView/>; event-flow)
+   │     └─ analysis/    page.tsx       REWRITE  (client <AnalysisView/>; query console)
+   ├─ components/
+   │  ├─ ui/                            DELETE   (all 50 shadcn primitives)
+   │  ├─ primitives/   NEW             (Button, Input, Select, Dialog, Tooltip, Badge, Progress, Avatar, Skeleton, Toast, Sheet, index.ts)
+   │  ├─ motion/       NEW             (variants.ts, Stagger.tsx, RouteTransition.tsx)
+   │  ├─ three/        NEW             (WebGLGuard, SignalField, OrbField, StaticFallback, useThreeScene)
+   │  ├─ charts/       NEW             (Sparkline, AreaActivity, RadialGauge, SessionRibbon, Waveform)
+   │  ├─ layout/       REWRITE         (Spine NEW, StatusBar NEW, ThemeToggle REWRITE, app-sidebar DELETE)
+   │  ├─ dashboard/    REWRITE         (stat-card DELETE; activity-chart/hourly/top-channels/moderation-donut/users/channels/reactions REWRITE)
+   │  ├─ messages/     REWRITE         (message-card DELETE; message-list/detail/detail-view/ai-status-badge/ai-analysis-panel/attachments-grid/lightbox/search-overlay REWRITE)
+   │  ├─ voice/        REWRITE         (voice-connection-card/connection-card/microphone-card DELETE; speaker-waveform/active-speakers-panel/activity-timeline/mic-control/listen-control REWRITE)
+   │  ├─ media/        REWRITE         (music-player, mini-player REWRITE)
+   │  ├─ recordings/   REWRITE         (recording-card DELETE; recording-player REWRITE)
+   │  ├─ moderation/   REWRITE         (moderation-section REWRITE)
+   │  ├─ analysis/     REWRITE         (search-panel REWRITE)
+   │  ├─ chatbot/      REWRITE         (chatbot-container, chat-panel REWRITE; chatbot-context, index KEEP)
+   │  └─ shared/       REWRITE         (empty-state, error-state, loading-skeleton, error-boundary, guild-selector REWRITE; index KEEP)
+   ├─ hooks/                           KEEP     (verify no bad imports)
+   ├─ lib/
+   │  ├─ api/          KEEP     (server.ts, client.ts, index.ts)
+   │  ├─ ws/           KEEP     (connection.ts, context.tsx, types.ts, ws-hook.ts)
+   │  ├─ types/        KEEP     (all interfaces)
+   │  ├─ hooks/        KEEP     (use-media-player.tsx, use-mounted.ts)
+   │  ├─ audio/        KEEP     (voice PCM decode helpers if present)
+   │  ├─ format.ts     KEEP
+   │  ├─ utils.ts      KEEP     (cn)
+   │  └─ navigation.ts KEEP
+   └─ (public assets)  KEEP
+```
+
+### 4.1 Single-file page pattern (mandatory)
+```tsx
+// server component (default export) — runs on the server, fetches initial data
+import { getX, getY } from "@/lib/api/server";
+import { XView } from "./page"; // self-import of the named client export
+
+export default async function Page() {
+  const [a, b] = await Promise.allSettled([getX(), getY()]);
+  return <XView initialA={a.status === "fulfilled" ? a.value : undefined}
+                  initialB={b.status === "fulfilled" ? b.value : undefined} />;
+}
+
+// client component (named export) — hydrated, takes initialData as SWR fallback
+"use client";
+export function XView({ initialA, initialB }: Props) {
+  const { data } = useX(initialA); // SWR fallbackData = initialA
+}
+```
+Self-referencing the named export keeps the file single-artifact while satisfying Next's RSC boundary (default = server, named = client). Tabs live inside `XView`.
+
+### 4.2 Import rules (lint gate)
+- No `@/components/ui/*` (deleted) — all UI via `@/components/primitives`.
+- `three` only imported inside `src/components/three/*`; pages import those via `next/dynamic({ ssr: false })`.
+- `motion` imported from `motion/react` only.
+- All data: `@/lib/api/server` (server) / `@/lib/api/client` (client) — never invented endpoints.
+
+---
+
+## TASKS (granular — every file is its own task)
+
+### PHASE 0 — Dependency surgery
+- **T0.1** Edit `package.json`: remove `dependencies["@base-ui/react"]`.
+- **T0.2** Remove `dependencies["@shadcn/react"]`.
+- **T0.3** Remove `dependencies["shadcn"]`.
+- **T0.4** Remove `dependencies["recharts"]`.
+- **T0.5** Remove `dependencies["cmdk"]`.
+- **T0.6** Remove `dependencies["sonner"]`.
+- **T0.7** Remove `dependencies["react-day-picker"]`.
+- **T0.8** Remove `dependencies["embla-carousel-react"]`.
+- **T0.9** Remove `dependencies["react-resizable-panels"]`.
+- **T0.10** Remove `dependencies["input-otp"]`.
+- **T0.11** Add `dependencies["motion"]: "^12.0.0"`, `dependencies["three"]: "^0.180.0"`, `devDependencies["@types/three"]: "^0.180.0"`.
+- **T0.12** `rm -f pnpm-lock.yaml && pnpm install` (regenerate lockfile).
+- **T0.13** Verify `pnpm ls recharts @shadcn/react @base-ui/react` → empty; `pnpm ls motion three @types/three` → present.
+- **T0.14** `cat pnpm-workspace.yaml`: confirm `onlyBuiltDependencies` keeps needed native builds, no broken shadcn postinstall.
+
+### PHASE 1 — Design tokens (globals.css)
+- **T1.1** Rewrite `@theme { }` head: light `:root` palette from §0 (canvas/surface/ink/ink-soft/hairline/signal/signal-ink/amber/vermilion/ring).
+- **T1.2** Add radius tokens `--r: 14px`, `--r-panel: 12px`, `--r-control: 8px`, `--r-pill: 9999px`.
+- **T1.3** Add `--font-display` token; keep `--font-sans`/`--font-mono`.
+- **T1.4** Add `.dark { }` override block with §0 dark values (warm charcoal).
+- **T1.5** Replace `@layer base body` bg: warm dot-grid `radial-gradient(oklch(0.45 0.03 70 / 0.05) 1px, transparent 1px)` + faint warm glow; remove old bluish radial layers.
+- **T1.6** Retint scrollbar thumb to warm `oklch(0.4 0.02 70 / 0.2)`; keep `::selection` signal-tinted.
+- **T1.7** Delete `.glass`, `.glass-elevated`, `.glass-intense`, `.dark .glass-intense` utilities.
+- **T1.8** Delete `.text-gradient` and `.gradient-border`.
+- **T1.9** Add `.surface` utility (bg var(--surface), radius var(--r), padding).
+- **T1.10** Add `.scan-tick` (1px animated pulse line, keyframe `scan`).
+- **T1.11** Add `.ticker`, `.pill`, `.mono` utilities.
+- **T1.12** Add keyframes `scan`, `eq`, `fade-up`, `spin-disc` (keep used existing ones if still referenced).
+- **T1.13** Add `@media (prefers-reduced-motion: reduce)` kill switch for scan/eq/spin-disc/pulse-ring/shimmer.
+- **T1.14** Remove `@import "shadcn/tailwind.css";` (line 3); verify nothing else depends on shadcn CSS vars.
+- **T1.15** Verify `grep -c "0.52 0.17 215\|0.55 0.2 280" src/app/globals.css` → `0`.
+- **T1.16** `pnpm biome check src/app/globals.css` → no errors.
+
+### PHASE 2 — Root layout + fonts
+- **T2.1** In `layout.tsx` add `Bricolage_Grotesque` (`variable: "--font-display"`, subsets `["latin"]`, `display: "swap"`).
+- **T2.2** Apply `inter.variable`, `jetbrainsMono.variable`, `bricolage.variable` to `<html>`.
+- **T2.3** Remove `import { Toaster } from "@/components/ui/sonner"`.
+- **T2.4** Comment out `<Toaster />` temporarily (re-enabled after T3.10).
+- **T2.5** Keep `suppressHydrationWarning`, `ThemeProvider` (defaultTheme dark, enableSystem false).
+- **T2.6** `npx tsc --noEmit` (fonts only; rest may still error until primitives exist).
+
+### PHASE 3 — Custom primitives (replace 50 shadcn ui)
+- **T3.1** `primitives/Button.tsx`: `motion.button`, variants `primary`/`ghost`/`danger`, `cn()` merge, `cursor-pointer`, `focus-visible:ring-2 ring-signal`, `whileTap` scale 0.97 gated by `useReducedMotion()`.
+- **T3.2** `primitives/Input.tsx`: native `<input>`, `bg-surface`, `rounded-[var(--r-control)]`, `mono` prop.
+- **T3.3** `primitives/Select.tsx`: native `<select>` styled, `bg-surface`.
+- **T3.4** `primitives/Dialog.tsx`: native `<dialog>` + `showModal()`, warm `::backdrop`, `AnimatePresence`, `onClose`.
+- **T3.5** `primitives/Tooltip.tsx`: CSS group-hover popover.
+- **T3.6** `primitives/Badge.tsx`: tonal pill, `variant` → `bg-{tone}/15 text-{tone}` (signal/amber/vermilion/neutral).
+- **T3.7** `primitives/Progress.tsx`: SVG track + `motion` fill, `value`/`max`, signal color.
+- **T3.8** `primitives/Avatar.tsx`: `<img>` + initials fallback, signal bg, size prop.
+- **T3.9** `primitives/Skeleton.tsx`: shimmer block (signal-tinted), `aria-hidden`.
+- **T3.10** `primitives/Toast.tsx`: `ToastProvider` context + portal, `useToast()`, motion slide-in, auto-dismiss.
+- **T3.11** `primitives/Sheet.tsx`: mobile drawer (`translate-x` spring), overlay, `open`/`onClose`.
+- **T3.12** `primitives/index.ts` re-export all 11.
+- **T3.13** Re-enable `<Toaster />` in `layout.tsx` (T2.4).
+- **T3.14** Verify `npx tsc --noEmit` on primitives; `grep -rl "@/components/ui/" src/components/primitives` → empty.
+
+### PHASE 4 — Motion foundation
+- **T4.1** `motion/variants.ts`: export `spring`, `ease`, `fadeUp`, `stagger` (per §0.1).
+- **T4.2** `motion/Stagger.tsx`: `StaggerGroup` + `StaggerItem` (`"use client"`).
+- **T4.3** `motion/RouteTransition.tsx`: `"use client"`, `usePathname`, `AnimatePresence mode="popLayout"`, reduced-motion fallback to plain `<div>`.
+- **T4.4** Verify `npx tsc --noEmit` on motion; `motion/react` import resolves.
+
+### PHASE 5 — Custom SVG charts (replace recharts)
+- **T5.1** `charts/Sparkline.tsx`: `<svg>` polyline from `points:number[]`, signal stroke, no axes.
+- **T5.2** `charts/AreaActivity.tsx`: filled `<path>` area, low-opacity signal gradient, `pathLength` draw gated by reduced-motion.
+- **T5.3** `charts/RadialGauge.tsx`: `<circle>` arc `stroke-dasharray`, center mono label.
+- **T5.4** `charts/SessionRibbon.tsx`: horizontal segments per speaker duration.
+- **T5.5** `charts/Waveform.tsx`: bars from deterministic seed, spring scaleY on hover.
+- **T5.6** Verify `npx tsc --noEmit` on charts; no `recharts` import.
+
+### PHASE 6 — Three.js foundation (lazy, guarded)
+- **T6.1** `three/WebGLGuard.tsx`: `"use client"`, detect webgl2/webgl, render `children` or `fallback`.
+- **T6.2** `three/useThreeScene.ts`: shared hook — renderer init (`dpr:[1,1.75]`, `powerPreference`), RAF with `document.hidden` pause, `dispose()` on unmount, resize observer.
+- **T6.3** `three/SignalField.tsx`: `Points` BufferGeometry (~min(900, w*h/2000)), additive blend, signal-lime, fog, idle rotation + sine drift, `activity` prop, pointer parallax. Uses `useThreeScene`.
+- **T6.4** `three/OrbField.tsx`: per-speaker `Sphere`, y-scale + ring lerp to speaking, tones signal/idle/vermilion.
+- **T6.5** `three/StaticFallback.tsx`: 2D SVG/CSS silhouette for both scenes.
+- **T6.6** Verify `grep -rl "from \"three\"" src | grep -v "components/three"` → empty; `npx tsc --noEmit` on three.
+
+### PHASE 7 — Layout shell
+- **T7.1** `layout/Spine.tsx`: `"use client"`, vertical rail from `navItems`, icon node + hairline, active signal dot + label reveal (motion spring), `max-md:` bottom tab-bar.
+- **T7.2** `layout/StatusBar.tsx`: `"use client"`, page title + WS status dot (motion pulse) + `GuildSelector` + live clock (mono) + `ThemeToggle`.
+- **T7.3** `layout/ThemeToggle.tsx`: restyle, keep `next-themes` logic, motion icon swap.
+- **T7.4** Rewrite `(dashboard)/layout.tsx`: keep SWRConfig/WsProvider/MediaPlayerProvider/ChatbotProvider + sync functions verbatim; swap `AppSidebar`→`Spine`, header→`StatusBar`, wrap children in `RouteTransition`; remove `SidebarInset`/`SidebarTrigger`/`Separator`; keep MiniPlayer+ChatbotContainer.
+- **T7.5** Delete `layout/app-sidebar.tsx`.
+- **T7.6** Verify `grep -rl "components/ui/sidebar\|app-sidebar" src` → empty; `npx tsc --noEmit`.
+
+### PHASE 8 — Dashboard page + components
+- **T8.1** Rewrite `dashboard/page.tsx`: default async `getDashboardStats`+`getActivity` → `<DashboardView>`; named `"use client"` view with useStats/useActivity, 3D hero + tickers + tabs.
+- **T8.2** Add `WebGLGuard`+`SignalField` hero with `activity` ratio; overlay headline (Bricolage) + `<RadialGauge>`.
+- **T8.3** Build asymmetric ticker row with `StaggerGroup` + 4 `.surface` blocks (mono number + label + `<Sparkline>`); inline (replaces stat-card).
+- **T8.4** Delete `dashboard/stat-card.tsx`.
+- **T8.5** Reskin `dashboard/activity-chart.tsx` → `charts/AreaActivity` (daily).
+- **T8.6** Reskin `dashboard/hourly-activity-chart.tsx` → `charts/AreaActivity` (hourly).
+- **T8.7** Reskin `dashboard/top-channels-chart.tsx` → `charts/` + `.surface`.
+- **T8.8** Reskin `dashboard/moderation-donut.tsx` → `charts/RadialGauge`.
+- **T8.9** Reskin `dashboard/users-section.tsx` → `.surface`.
+- **T8.10** Reskin `dashboard/channels-section.tsx` → `.surface`.
+- **T8.11** Reskin `dashboard/reactions-section.tsx` → `.surface`.
+- **T8.12** Verify `grep -rl "components/ui/card" src/app/\(dashboard\)/dashboard src/components/dashboard` → empty; `npx tsc --noEmit`.
+
+### PHASE 9 — Messages page + components
+- **T9.1** Rewrite `messages/page.tsx`: default `getMessages(guildId)`(+channels) → `<MessagesView>`; client spine + entries.
+- **T9.2** Delete `messages/message-card.tsx`.
+- **T9.3** Rewrite `messages/message-list.tsx`: left timeline spine + right severity-tick entries (`surface` + `border-l-2` lime/amber/vermilion, motion spring tick), `layout` reflow.
+- **T9.4** Rewrite `messages/message-detail.tsx` → `.surface`.
+- **T9.5** Rewrite `messages/message-detail-view.tsx` → `.surface` pane.
+- **T9.6** Rewrite `messages/ai-status-badge.tsx` → `primitives/Badge`.
+- **T9.7** Rewrite `messages/ai-analysis-panel.tsx` → `.surface`.
+- **T9.8** Rewrite `messages/attachments-grid.tsx` → `.surface` grid.
+- **T9.9** Rewrite `messages/lightbox.tsx` → `primitives/Dialog`.
+- **T9.10** Rewrite `messages/search-overlay.tsx` → console palette, type-in animation, `primitives/Dialog`.
+- **T9.11** Verify no `components/ui/card` in messages tree; `npx tsc --noEmit`.
+
+### PHASE 10 — Voice page + components
+- **T10.1** Rewrite `voice/page.tsx`: default `getVoiceStatus()` → `<VoiceView>`; client `WebGLGuard`+`OrbField` hero + ribbon + tabs.
+- **T10.2** Delete `voice/voice-connection-card.tsx`, `connection-card.tsx`, `microphone-card.tsx`.
+- **T10.3** Rewrite `voice/speaker-waveform.tsx` → SVG ring / eq bars.
+- **T10.4** Rewrite `voice/active-speakers-panel.tsx` → `.surface`.
+- **T10.5** Rewrite `voice/activity-timeline.tsx` → `charts/SessionRibbon`.
+- **T10.6** Rewrite `voice/mic-control.tsx` → `primitives/Button`.
+- **T10.7** Rewrite `voice/listen-control.tsx` → `primitives/Button`.
+- **T10.8** Verify `npx tsc --noEmit`; no `components/ui/card` in voice tree.
+
+### PHASE 11 — Media page + components
+- **T11.1** Rewrite `media/page.tsx`: default `getMediaStatus()` → `<MediaView>`; client turntable disc + transport + queue.
+- **T11.2** Rewrite `media/music-player.tsx`: CSS-3D disc (spin-disc, pause when not playing, spring on play/pause), mono meta, `primitives/Button` transport, `.surface` queue rows with `layout`.
+- **T11.3** Rewrite `media/mini-player.tsx` → compact `.surface`.
+- **T11.4** Verify `npx tsc --noEmit`; no `components/ui/card` in media tree.
+
+### PHASE 12 — Recordings page + components
+- **T12.1** Rewrite `recordings/page.tsx`: default `getRecordings(50)` → `<RecordingsView>`; client rows `AnimatePresence`+`layout`, live `voice_recording_uploaded` prepend.
+- **T12.2** Delete `recordings/recording-card.tsx`.
+- **T12.3** Rewrite `recordings/recording-player.tsx` → `.surface` row + `charts/Waveform` + `primitives/Button`/`Dialog` play/delete.
+- **T12.4** Verify `npx tsc --noEmit`.
+
+### PHASE 13 — Moderation + Analysis pages
+- **T13.1** Rewrite `moderation/page.tsx`: default `getModerationStats/Actions` → `<ModerationView>`; client vertical event-flow, live actions pulse-in.
+- **T13.2** Rewrite `moderation/moderation-section.tsx` → event-flow, no Card/table.
+- **T13.3** Rewrite `analysis/page.tsx`: client `<AnalysisView/>` terminal console (`primitives/Input` mono + blinking caret, `.surface` results staggered).
+- **T13.4** Rewrite `analysis/search-panel.tsx` → terminal style.
+- **T13.5** Verify `npx tsc --noEmit`.
+
+### PHASE 14 — Chatbot + shared + final cleanup
+- **T14.1** Rewrite `chatbot/chatbot-container.tsx` → `.surface`, keep drag/minimize.
+- **T14.2** Rewrite `chatbot/chat-panel.tsx` → bubbles via `AnimatePresence`, `primitives/*`.
+- **T14.3** Keep `chatbot/chatbot-context.tsx` + `index.ts`.
+- **T14.4** Rewrite `shared/empty-state.tsx` → tonal.
+- **T14.5** Rewrite `shared/error-state.tsx`.
+- **T14.6** Rewrite `shared/loading-skeleton.tsx` → `primitives/Skeleton`.
+- **T14.7** Rewrite `shared/error-boundary.tsx`.
+- **T14.8** Rewrite `shared/guild-selector.tsx` → `primitives/Select`.
+- **T14.9** `rm -rf src/components/ui && rm -f components.json`.
+- **T14.10** `grep -rn "components/ui/\|@shadcn\|@base-ui\|recharts" src` → MUST be empty.
+- **T14.11** `grep -rl "from \"recharts\"\|@base-ui\|@shadcn" src` → empty (double-check).
+- **T14.12** Verify `npx tsc --noEmit` across whole `src`.
+
+### PHASE 15 — Build + lint gate
+- **T15.1** `cd services/frontend && npx tsc --noEmit` → 0 errors.
+- **T15.2** `pnpm biome check` → fix all issues (no `any` in new files).
+- **T15.3** `pnpm build` (standalone) → success, emits `.next/standalone/server.js`.
+- **T15.4** Inspect `.next/static/chunks/` for three-heavy chunk loaded only on dashboard/voice; confirm NOT in `/dashboard/` initial SSR HTML.
+- **T15.5** Confirm `pnpm-lock.yaml` present (reproducible flake install).
+- **T15.6** `grep -c "0.52 0.17 215\|0.55 0.2 280" .next/static/css/*.css` → 0.
+
+### PHASE 16 — Local runtime smoke test (no prod)
+- **T16.1** Start local standalone: `GMW_BACKEND_URL=http://127.0.0.1:4001 PORT=4017 node .next/standalone/server.js &`.
+- **T16.2** `curl -s -o /dev/null -w "%{http_code}"` for all 7 routes → 200.
+- **T16.3** `curl /dashboard/ | grep -o "Bricolage\|signal\|surface"` → present.
+- **T16.4** `curl /_next/static/css/*.css | grep "0.52 0.17 215\|0.55 0.2 280"` → empty.
+- **T16.5** Headless browser `/dashboard/`+`/voice/` WebGL on: no console errors, `<canvas>` present, `<StaticFallback/>` NOT rendered.
+- **T16.6** Same pages WebGL off: `<StaticFallback/>` renders, no crash.
+- **T16.7** Kill local server. Do NOT touch prod unit.
+- **T16.8** Confirm 7 routes 200 + no console errors in T16.5/16.6.
+
+### PHASE 17 — Flake + staging deploy
+- **T17.1** Inspect `flake.nix` frontend drv: `filterSource` ignores `out/.next/node_modules`; `pnpm-lock.yaml` included.
+- **T17.2** `nix build .#gmw-frontend --impure --sandbox-off` → succeeds.
+- **T17.3** `nix copy` frontend drv to VPS into staging profile (test port e.g. 4217).
+- **T17.4** Create/adjust staging systemd unit with `PORT=4217` exported BEFORE `node server.js` (LIDM PORT bug).
+- **T17.5** `sudo systemctl restart gmw-frontend-staging`; `curl` staging → 200.
+- **T17.6** Browser-check staging `/dashboard/`+`/voice/` (3D visible, fallback test).
+- **T17.7** Verify staging CSS has no old teal/purple; new design renders.
+
+### PHASE 18 — Production swap (CONFIRM WITH USER FIRST)
+- **T18.1** STOP — send staging screenshots/URL; await explicit approval before touching prod.
+- **T18.2** On approval: `nix-env --profile /nix/var/nix/profiles/gmw-frontend --set <new-drv>`.
+- **T18.3** Confirm `gmw-frontend.service` exports `PORT=4017` before exec.
+- **T18.4** `sudo systemctl restart gmw-frontend`.
+- **T18.5** `curl` all 7 routes on `https://imphnen.asepharyana.my.id` → 200.
+- **T18.6** Browser verify prod: new design, old teal gone, 3D scenes render.
+- **T18.7** `journalctl -u gmw-frontend -f` 5 min; confirm WS reconnect + live features.
+- **T18.8** Notify user with before/after notes; keep rollback plan (`nix-env --set <previous>; systemctl restart`).
+
+---
+
+## Risks / Trade-offs
+- **Scope:** 7 pages + charts + primitives + motion + 2 three scenes + layout. Big but mechanical; each task is isolated (~90 atomic tasks).
+- **Bundle weight:** `three` adds ~150KB gz but ONLY on dashboard/voice routes (lazy chunk, `ssr:false`). `motion` ~35KB gz app-wide — acceptable.
+- **WebGL compatibility:** covered by `WebGLGuard` + static fallback. Old devices / strict privacy browsers never blank.
+- **Motion excess:** risk of "AI-generated" scattered animation. Guard: one signature moment per page, shared variants, reduced-motion gates.
+- **Feature regressions:** Voice PCM playback, media transport, chatbot drag — logic preserved, only skin changes. Smoke test (T16) catches SSR breaks; live WS/3D needs real backend (staging T17).
+- **Removed deps:** dropping `recharts`/`sonner`/`cmdk` means rewriting charts + toasts + search palette — accounted for in Phases 3/5/9.
+- **Next standalone PORT bug:** `server.js` may not read `PORT` — ensure unit exports `PORT=4017` before exec (T17.4/T18.3).
+- **three + React 19:** raw three avoids R3F compat surface; lifecycle (dispose + RAF) handled in T6.2.
+- **next-themes:** keep (light/dark toggle); default dark.
+
+## Open questions (answer before T18)
+- Q1: Deploy to prod now or staging-only first? (Recommend staging + screenshot review.)
+- Q2: Keep `react-day-picker`/`embla` if any page still needs them? (Plan assumes no — verify in T14.10 grep.)
+- Q3: Any brand name/wordmark change from "Discord Automod"? (Keep "Bete" identity unless told.)
+- Q4: 3D depth — full 3D scenes on dashboard+voice as specced, or also a 3D accent on media (disc)? (Default: dashboard+voice only; media disc stays CSS 3D.)

biome.json

@@ -35,12 +35,15 @@
       "suspicious": {
         "noUnknownAtRules": "off",
         "useIterableCallbackReturn": "off",
-        "noArrayIndexKey": "warn"
+        "noArrayIndexKey": "off",
+        "noExplicitAny": "off"
       },
       "a11y": {
         "useSemanticElements": "off",
         "useButtonType": "off",
-        "noAutofocus": "off"
+        "noAutofocus": "off",
+        "useMediaCaption": "off",
+        "noStaticElementInteractions": "off"
       },
       "performance": {
         "noImgElement": "warn"
@@ -50,7 +53,10 @@
       },
       "correctness": {
         "noInvalidUseBeforeDeclaration": "off",
-        "noUnusedFunctionParameters": "warn"
+        "noUnusedFunctionParameters": "warn",
+        "noUnusedVariables": "warn",
+        "noUnusedImports": "warn",
+        "noUnusedPrivateClassMembers": "warn"
       }
     },
     "domains": {

flake.nix

@@ -11,11 +11,6 @@
       let
         pkgs = import nixpkgs { inherit system; };
 
-        # libdatachannel for the GoLive N-API binding. nixpkgs 0.24.1 is built
-        # against this host's glibc and ships both lib + dev headers, so the
-        # binding links cleanly inside the Nix sandbox (no manual cmake build).
-        libdatachannel = pkgs.libdatachannel;
-
         # Source filter: `path:` literals do NOT respect .gitignore by default,
         # so a dirty local out/ (stale chunks from previous builds) leaks into
         # the sandbox. Filter out build artifacts explicitly.
@@ -53,8 +48,8 @@
           export GIT_SSL_CAINFO=${pkgs.cacert}/etc/ssl/certs/ca-bundle.crt
           export NIX_SSL_CERT_FILE=${pkgs.cacert}/etc/ssl/certs/ca-bundle.crt
 
-          # pnpm uses node-gyp for native addons — provide build tools
-          export npm_config_build_from_source=true
+          # pnpm uses node-gyp for native addons — provide build tools (kept for
+          # the rare case a prebuilt is unavailable and it falls back to compile).
           export CPPFLAGS="-I${pkgs.lib.getDev pkgs.openssl}/include"
           export LDFLAGS="-L${pkgs.lib.getLib pkgs.openssl}/lib"
 
@@ -73,7 +68,7 @@
         # NOTE: do NOT use `pnpm install --prod` here — it collapses the
         # public-hoist dir (.pnpm/node_modules) that runtime peer resolution
         # relies on (e.g. @lng2004/node-datachannel and @seydx/node-av-linux-x64
-        # are only reachable through it), silently breaking voice/screenshare.
+        # are only reachable through it), silently breaking voice.
         # Instead we keep the full install's symlink layout and only prune
         # orphaned package dirs + broken symlinks.
         # Must run AFTER tsc (typescript is a devDep) and after native builds.
@@ -167,8 +162,7 @@ WRAPPER
             pkgs.pkg-config
             pkgs.openssl
             pkgs.openssl.dev
-            libdatachannel.dev # rtc/rtc.hpp headers for the GoLive binding
-            pkgs.git # libdatachannel FetchContent clones from GitHub
+            pkgs.git # for any FetchContent-based deps during native builds
             pkgs.cacert
           ];
 
@@ -181,38 +175,31 @@ WRAPPER
           # do NOT let stdenv run its own cmake configure phase on the source.
           dontUseCmakeConfigure = true;
 
+          # The gateway bundles native node_modules (.node addons plus .o/.a
+          # object files left in prebuilt dirs). stdenv's fixupPhase walks
+          # $out/node_modules and runs patchELF + shrinkELF over every ELF it
+          # finds, choking on the non-ET_DYN files (.o/.a) and the prebuilt
+          # .node addons — emitting hundreds of harmless "patchelf: wrong ELF
+          # type" lines per build. The real binary is node (external, already
+          # RPATH-fixed in its own derivation) and the .node addons are
+          # self-contained prebuilts loaded via dlopen, so Nix's fixup pass is
+          # neither needed nor wanted here. Skip it entirely.
+          dontFixup = true;
+
           buildPhase = pnpmInstall + ''
             echo "=== Building native voice deps ==="
             # pnpm rebuild aborts on the first failing package and runs scripts
             # from the wrong cwd — build each native dep explicitly with its own
             # install script. Each failure is tolerated (|| true); the packages
-            # that matter (opus) are verified at runtime.
-            for pkg in \
-              node_modules/.pnpm/@discordjs+opus@*/node_modules/@discordjs/opus
-            do
-              if [ -d "$pkg" ]; then
-                echo "--- native build: $pkg ---"
-                (cd "$pkg" && npm run install 2>&1 || true)
-              fi
-            done
-            echo "=== Building libdatachannel-min N-API binding ==="
-            # The GoLive screen-share stack uses a minimal N-API binding
-            # (native/libdatachannel-min) over nixpkgs libdatachannel.
-            (
-              cd native/libdatachannel-min
-              # binding.gyp resolves include/lib from env (LDC_INCLUDE = .dev
-              # include root, LDC_LIB = lib output dir, NAPI_INCLUDE =
-              # node-addon-api include root).
-              NAPI_INCLUDE=$(find ../../node_modules/.pnpm -maxdepth 3 \
-                -type d -path "*node_modules/node-addon-api" | head -1)
-              echo "NAPI_INCLUDE=$NAPI_INCLUDE"
-              LDC_INCLUDE=${libdatachannel.dev} LDC_LIB=${libdatachannel.out}/lib/libdatachannel.so.0.24.1 \
-                NAPI_INCLUDE=$NAPI_INCLUDE \
-                npx node-gyp rebuild 2>&1 || true
-              ls -la build/Release/datachannel_min.node 2>/dev/null \
-                && echo "libdatachannel-min binding OK: $(stat -c%s build/Release/datachannel_min.node) bytes" \
-                || echo "WARN: libdatachannel-min binding build FAILED (screen share disabled)"
-            )
+            # @discordjs/opus ships prebuilt binaries for Node 22 (ABI node-v127,
+            # linux-x64-glibc-2.35) — node-pre-gyp downloads the prebuilt .node
+            # instead of compiling C++ from source. With build_from_source unset
+            # (above), `pnpm rebuild` runs the package's own install script which
+            # fetches the matching prebuilt; it only falls back to a source build
+            # if the download fails. This keeps voice working without a per-build
+            # native compile.
+            echo "=== Rebuilding @discordjs/opus (prebuilt download) ==="
+            pnpm rebuild @discordjs/opus 2>&1 || true
             echo "=== Compiling TypeScript ===="
             npx tsc 2>&1
             echo "=== Fixing @/ path aliases to relative paths ==="
@@ -247,22 +234,6 @@ WRAPPER
             mkdir -p $out/lib/gmw-discord-gateway
             cp -r dist node_modules package.json tsconfig.json $out/lib/gmw-discord-gateway/
 
-            # GoLive native binding — loadNative resolves it relative to
-            # dist/goLive/native.js, i.e. <root>/native/libdatachannel-min/
-            # build/Release/datachannel_min.node; libdatachannel .so must sit
-            # next to it and be on LD_LIBRARY_PATH at runtime.
-            mkdir -p $out/lib/gmw-discord-gateway/native/libdatachannel-min/build/Release
-            cp native/libdatachannel-min/build/Release/datachannel_min.node \
-              $out/lib/gmw-discord-gateway/native/libdatachannel-min/build/Release/ 2>/dev/null || true
-            mkdir -p $out/lib/gmw-discord-gateway/native/libdatachannel-min/build/ldc
-            cp -rL native/libdatachannel-min/build/ldc/libdatachannel.so* \
-              $out/lib/gmw-discord-gateway/native/libdatachannel-min/build/ldc/ 2>/dev/null || true
-            # If the binding failed to build, screen share is simply disabled —
-            # the gateway itself must still start.
-            if [ ! -f $out/lib/gmw-discord-gateway/native/libdatachannel-min/build/Release/datachannel_min.node ]; then
-              echo "WARN: datachannel_min.node missing — GoLive screen share disabled in this build"
-            fi
-
             # Also include drizzle migrations if they exist
             cp -r drizzle $out/lib/gmw-discord-gateway/ 2>/dev/null || true
 
@@ -271,7 +242,6 @@ WRAPPER
 #!${pkgs.runtimeShell}
 cd $out/lib/gmw-discord-gateway
 export PATH=${pkgs.ffmpeg-headless}/bin:${pkgs.yt-dlp}/bin:\$PATH
-export LD_LIBRARY_PATH=${libdatachannel.out}/lib:\$LD_LIBRARY_PATH
 exec ${nodejs}/bin/node dist/index.js
 WRAPPER
             chmod +x $out/bin/gmw-discord-gateway

scripts/add-ai-analysis-duration.sql

@@ -0,0 +1,10 @@
+-- Migration: add ai_analysis_duration_ms to messages
+-- Tracks how long the AI moderation LLM call took, per message (ms).
+-- Idempotent: safe to re-run.
+--
+-- Run against the production GMW database, e.g.:
+--   PGPASSWORD=*** psql -h 100.121.180.82 -p 6432 -U asephs -d dcbot \
+--     -f scripts/add-ai-analysis-duration.sql
+
+ALTER TABLE "messages"
+  ADD COLUMN IF NOT EXISTS "ai_analysis_duration_ms" BIGINT;

services/backend/src/modules/messages/messages.repository.ts

@@ -77,12 +77,11 @@ export class MessagesRepository {
 
     // Exclude spam threads (NULL-safe: non-thread messages are kept)
     if (EXCLUDED_THREAD_IDS.length > 0) {
-      conditions.push(
-        or(
+      const excludeThreads = or(
         isNull(pgMessagesTable.thread_id),
         notInArray(pgMessagesTable.thread_id, EXCLUDED_THREAD_IDS),
-        )!,
       );
+      if (excludeThreads) conditions.push(excludeThreads);
     }
 
     const where = conditions.length > 0 ? and(...conditions) : undefined;
@@ -150,12 +149,11 @@ export class MessagesRepository {
 
     // Exclude spam threads (NULL-safe)
     if (EXCLUDED_THREAD_IDS.length > 0) {
-      conditions.push(
-        or(
+      const excludeThreads = or(
         isNull(pgMessagesTable.thread_id),
         notInArray(pgMessagesTable.thread_id, EXCLUDED_THREAD_IDS),
-        )!,
       );
+      if (excludeThreads) conditions.push(excludeThreads);
     }
 
     const rows = await db
@@ -316,12 +314,13 @@ export class MessagesRepository {
           like(pgAttachmentsTable.type, "image/%"),
           // Exclude spam threads (NULL-safe for non-thread messages)
           ...(EXCLUDED_THREAD_IDS.length > 0
-            ? [
-                or(
+            ? (() => {
+                const excludeThreads = or(
                   isNull(pgAttachmentsTable.thread_id),
                   notInArray(pgAttachmentsTable.thread_id, EXCLUDED_THREAD_IDS),
-                )!,
-              ]
+                );
+                return excludeThreads ? [excludeThreads] : [];
+              })()
             : []),
         ),
       )

services/backend/src/shared/database/schema.ts

@@ -62,6 +62,9 @@ export const pgMessagesTable = pgTable(
       enum: ["none", "monitor", "warn", "review", "delete", "escalate"],
     }),
     ai_analyzed_at: pgBigint("ai_analyzed_at", { mode: "number" }),
+    ai_analysis_duration_ms: pgBigint("ai_analysis_duration_ms", {
+      mode: "number",
+    }),
     ai_error: pgText("ai_error"),
   },
   (table) => ({

services/backend/src/shared/moderation-types.ts

@@ -80,6 +80,7 @@ export interface MessageRecord {
   ai_confidence?: number | null;
   ai_recommended_action?: AIRecommendedAction | null;
   ai_analyzed_at?: number | null;
+  ai_analysis_duration_ms?: number | null;
   ai_error?: string | null;
 }
 

services/backend/src/shared/utils/index.ts

@@ -108,5 +108,5 @@ export async function retryWithBackoff<T>(
       });
     }
   }
-  throw lastError!;
+  throw lastError ?? new Error("Request failed after all retries");
 }

services/backend/src/shared/utils/messageMapper.ts

@@ -24,6 +24,7 @@ export interface MappedMessage {
   ai_confidence: number | null;
   ai_recommended_action: string | null;
   ai_analyzed_at: number | null;
+  ai_analysis_duration_ms: number | null;
   ai_error: string | null;
   is_reply: boolean | null;
   is_forward: boolean | null;
@@ -58,6 +59,8 @@ export function mapMessageRow(row: Record<string, unknown>): MappedMessage {
     ai_confidence: (row.ai_confidence as number | null) ?? null,
     ai_recommended_action: (row.ai_recommended_action as string | null) ?? null,
     ai_analyzed_at: (row.ai_analyzed_at as number | null) ?? null,
+    ai_analysis_duration_ms:
+      (row.ai_analysis_duration_ms as number | null) ?? null,
     ai_error: (row.ai_error as string | null) ?? null,
     is_reply: row.is_reply === null ? null : Boolean(row.is_reply),
     is_forward: row.is_forward === null ? null : Boolean(row.is_forward),

services/discord-gateway/drizzle/migrations/0014_add_term_glossary_cache.sql

@@ -0,0 +1,9 @@
+CREATE TABLE IF NOT EXISTS "term_glossary_cache" (
+	"term" text PRIMARY KEY NOT NULL,
+	"definition" text NOT NULL,
+	"source_url" text DEFAULT '' NOT NULL,
+	"resolved_at" bigint NOT NULL,
+	"hit_count" integer DEFAULT 0 NOT NULL
+);
+--> statement-breakpoint
+CREATE INDEX IF NOT EXISTS "idx_term_glossary_cache_resolved_at" ON "term_glossary_cache" USING btree ("resolved_at");

services/discord-gateway/drizzle/migrations/meta/_journal.json

@@ -99,6 +99,13 @@
       "when": 1785551832190,
       "tag": "0013_rename_mascot_chat_to_chatbot",
       "breakpoints": true
+    },
+    {
+      "idx": 14,
+      "version": "7",
+      "when": 1785621600000,
+      "tag": "0014_add_term_glossary_cache",
+      "breakpoints": true
     }
   ]
 }

services/discord-gateway/native/libdatachannel-min/.gitignore

@@ -1,3 +0,0 @@
-node_modules/
-build/
-package-lock.json

services/discord-gateway/native/libdatachannel-min/binding.cpp

@@ -1,526 +0,0 @@
-// libdatachannel-min — minimal N-API binding to libdatachannel.
-// Exposes ONLY what GMW GoLive needs:
-//   PeerConnection (offer/answer, ICE, SDP), DataChannel (signaling),
-//   Track send (added in media phase).
-// Built against libdatachannel 0.24.0 (built from source in /tmp/ldc-build).
-
-#include <napi.h>
-#include <rtc/rtc.hpp>
-
-#include <functional>
-#include <memory>
-#include <string>
-#include <variant>
-
-using namespace Napi;
-
-namespace {
-
-std::string stateToString(rtc::PeerConnection::State s) {
-  switch (s) {
-    case rtc::PeerConnection::State::New: return "new";
-    case rtc::PeerConnection::State::Connecting: return "connecting";
-    case rtc::PeerConnection::State::Connected: return "connected";
-    case rtc::PeerConnection::State::Disconnected: return "disconnected";
-    case rtc::PeerConnection::State::Failed: return "failed";
-    case rtc::PeerConnection::State::Closed: return "closed";
-    default: return "unknown";
-  }
-}
-
-std::string binaryToString(const rtc::binary& data) {
-  // rtc::binary is std::vector<std::byte> in libdatachannel >= 0.21
-  std::string msg(data.size(), '\0');
-  for (size_t i = 0; i < data.size(); i++) {
-    msg[i] = static_cast<char>(data[i]);
-  }
-  return msg;
-}
-
-// Holds a Napi::Promise::Deferred so it can be moved into TSFN lambdas
-// without invalid copies (node-addon-api 8.x Deferred is not movable).
-struct DeferredHolder {
-  Promise::Deferred deferred;
-  explicit DeferredHolder(Promise::Deferred d) : deferred(d) {}
-};
-
-class DataChannelWrap : public Napi::ObjectWrap<DataChannelWrap> {
- public:
-  static Function Init(Napi::Env env) {
-    Function func = DefineClass(env, "DataChannel", {
-      InstanceMethod("send", &DataChannelWrap::Send),
-      InstanceMethod("isOpen", &DataChannelWrap::IsOpen),
-      InstanceMethod("close", &DataChannelWrap::Close),
-      InstanceMethod("onMessage", &DataChannelWrap::OnMessage),
-      InstanceMethod("onOpen", &DataChannelWrap::OnOpen),
-    });
-    dcConstructor = Napi::Persistent(func);
-    return func;
-  }
-
-  // Create a JS wrapper (calls the JS constructor, returns instance).
-  static Object NewInstance(Napi::Env env) {
-    return dcConstructor.New({});
-  }
-
-  DataChannelWrap(const Napi::CallbackInfo& info)
-      : Napi::ObjectWrap<DataChannelWrap>(info) {}
-
-  void Init(std::shared_ptr<rtc::DataChannel> dc) {
-    dc_ = dc;
-    dc_->onMessage([this](rtc::message_variant data) {
-      std::string msg;
-      if (std::holds_alternative<rtc::binary>(data)) {
-        msg = binaryToString(std::get<rtc::binary>(data));
-      } else {
-        msg = std::get<std::string>(data);
-      }
-      if (msgCb_) {
-        msgCb_->BlockingCall([msg](Napi::Env env, Function cb) {
-          cb.Call({String::New(env, msg)});
-        });
-      }
-    });
-    dc_->onOpen([this]() {
-      if (openCb_) {
-        openCb_->BlockingCall([](Napi::Env env, Function cb) {
-          cb.Call({});
-        });
-      }
-    });
-  }
-
- private:
-  static FunctionReference dcConstructor;
-  std::shared_ptr<rtc::DataChannel> dc_;
-  std::shared_ptr<ThreadSafeFunction> msgCb_;
-  std::shared_ptr<ThreadSafeFunction> openCb_;
-
-  void Send(const Napi::CallbackInfo& info) {
-    std::string msg = info[0].As<String>().Utf8Value();
-    if (dc_) dc_->send(msg);
-  }
-
-  Napi::Value IsOpen(const Napi::CallbackInfo& info) {
-    bool open = dc_ && dc_->isOpen();
-    return Boolean::New(info.Env(), open);
-  }
-
-  void Close(const Napi::CallbackInfo& info) {
-    if (dc_) dc_->close();
-  }
-
-  void OnMessage(const Napi::CallbackInfo& info) {
-    Function cb = info[0].As<Function>();
-    msgCb_ = std::make_shared<ThreadSafeFunction>(
-        ThreadSafeFunction::New(info.Env(), cb, "dc-message", 0, 1));
-  }
-
-  void OnOpen(const Napi::CallbackInfo& info) {
-    Function cb = info[0].As<Function>();
-    openCb_ = std::make_shared<ThreadSafeFunction>(
-        ThreadSafeFunction::New(info.Env(), cb, "dc-open", 0, 1));
-  }
-};
-
-class TrackWrap : public Napi::ObjectWrap<TrackWrap> {
- public:
-  static Function Init(Napi::Env env) {
-    Function func = DefineClass(env, "Track", {
-      InstanceMethod("send", &TrackWrap::Send),
-      InstanceMethod("isOpen", &TrackWrap::IsOpen),
-      InstanceMethod("close", &TrackWrap::Close),
-      InstanceMethod("setPacketizer", &TrackWrap::SetPacketizer),
-      InstanceMethod("sendFrame", &TrackWrap::SendFrame),
-      InstanceMethod("addTimestamp", &TrackWrap::AddTimestamp),
-    });
-    trackConstructor = Napi::Persistent(func);
-    return func;
-  }
-
-  static Object NewInstance(Napi::Env env) {
-    return trackConstructor.New({});
-  }
-
-  TrackWrap(const Napi::CallbackInfo& info)
-      : Napi::ObjectWrap<TrackWrap>(info) {}
-
-  void Init(std::shared_ptr<rtc::Track> track, Napi::Env env) {
-    track_ = track;
-    (void)env;
-  }
-
- private:
-  static FunctionReference trackConstructor;
-  std::shared_ptr<rtc::Track> track_;
-  std::shared_ptr<rtc::RtpPacketizationConfig> rtpConfig_;
-
-  void Send(const Napi::CallbackInfo& info) {
-    Buffer<uint8_t> buf = info[0].As<Buffer<uint8_t>>();
-    if (!track_) return;
-    rtc::binary data(buf.Length());
-    for (size_t i = 0; i < buf.Length(); i++) data[i] = (std::byte)buf[i];
-    try {
-      track_->send(data);
-    } catch (const std::exception& e) {
-      fprintf(stderr, "[binding] track.send THREW: %s\n", e.what());
-    }
-  }
-
-  // setPacketizer(kind, ssrc, payloadType, clockRate, playoutDelayId,
-  //               playoutDelayMin, playoutDelayMax)
-  // kind: "audio" | "h264" | "h265" | "av1"
-  // Builds the media-handler chain (packetizer → RTCP SR → NACK → pacing for
-  // video) exactly like @dank074's WebRtcWrapper does via node-datachannel.
-  void SetPacketizer(const Napi::CallbackInfo& info) {
-    Napi::Env env = info.Env();
-    if (!track_) throw Error::New(env, "track closed");
-    std::string kind = info[0].As<String>().Utf8Value();
-    uint32_t ssrc = info[1].As<Number>().Uint32Value();
-    uint8_t pt = (uint8_t)info[2].As<Number>().Uint32Value();
-    uint32_t clockRate = info[3].As<Number>().Uint32Value();
-    uint8_t playoutDelayId = (uint8_t)info[4].As<Number>().Uint32Value();
-    uint16_t playoutDelayMin = (uint16_t)info[5].As<Number>().Uint32Value();
-    uint16_t playoutDelayMax = (uint16_t)info[6].As<Number>().Uint32Value();
-    try {
-      auto cfg = std::make_shared<rtc::RtpPacketizationConfig>(
-          ssrc, "", pt, clockRate);
-      cfg->playoutDelayId = playoutDelayId;
-      cfg->playoutDelayMin = playoutDelayMin;
-      cfg->playoutDelayMax = playoutDelayMax;
-      std::shared_ptr<rtc::MediaHandler> handler;
-      if (kind == "audio") {
-        handler = std::make_shared<rtc::OpusRtpPacketizer>(cfg);
-      } else if (kind == "h264") {
-        handler = std::make_shared<rtc::H264RtpPacketizer>(
-            rtc::NalUnit::Separator::StartSequence, cfg);
-      } else if (kind == "h265") {
-        handler = std::make_shared<rtc::H265RtpPacketizer>(
-            rtc::NalUnit::Separator::StartSequence, cfg);
-      } else if (kind == "av1") {
-        handler = std::make_shared<rtc::AV1RtpPacketizer>(
-            rtc::AV1RtpPacketizer::Packetization::Obu, cfg);
-      } else {
-        throw std::runtime_error("unknown packetizer kind: " + kind);
-      }
-      handler->addToChain(std::make_shared<rtc::RtcpSrReporter>(cfg));
-      handler->addToChain(std::make_shared<rtc::RtcpNackResponder>());
-      if (kind != "audio") {
-        handler->addToChain(std::make_shared<rtc::PacingHandler>(
-            25.0 * 1000 * 1000, std::chrono::milliseconds(1)));
-      }
-      track_->setMediaHandler(handler);
-      rtpConfig_ = cfg;
-    } catch (const std::exception& e) {
-      fprintf(stderr, "[binding] setPacketizer THREW: %s\n", e.what());
-      throw Error::New(env, e.what());
-    }
-  }
-
-  // sendFrame(buffer) — sends an ENCODED frame (AnnexB H264 / raw opus /
-  // OBU AV1). The media-handler chain packetizes it into RTP.
-  void SendFrame(const Napi::CallbackInfo& info) {
-    Buffer<uint8_t> buf = info[0].As<Buffer<uint8_t>>();
-    if (!track_) return;
-    rtc::binary data(buf.Length());
-    for (size_t i = 0; i < buf.Length(); i++) data[i] = (std::byte)buf[i];
-    try {
-      track_->send(data);
-    } catch (const std::exception& e) {
-      fprintf(stderr, "[binding] track.sendFrame THREW: %s\n", e.what());
-    }
-  }
-
-  // addTimestamp(delta) — advances the packetizer RTP timestamp by delta
-  // (clock-rate units). Called by JS after each frame, matching the
-  // node-datachannel contract (WebRtcWrapper does the same increment).
-  void AddTimestamp(const Napi::CallbackInfo& info) {
-    uint32_t delta = info[0].As<Number>().Uint32Value();
-    if (rtpConfig_) rtpConfig_->timestamp += delta;
-  }
-
-  Napi::Value IsOpen(const Napi::CallbackInfo& info) {
-    bool open = track_ && track_->isOpen();
-    return Boolean::New(info.Env(), open);
-  }
-
-  void Close(const Napi::CallbackInfo& info) {
-    if (track_) track_->close();
-  }
-
-  void OnStateChange(const Napi::CallbackInfo& info) {
-    // libdatachannel Track has no state-change callback; kept for API parity.
-    (void)info;
-  }
-};
-class PeerConnectionWrap : public Napi::ObjectWrap<PeerConnectionWrap> {
- public:
-  static Function Init(Napi::Env env) {
-    Function func = DefineClass(env, "PeerConnection", {
-      InstanceMethod("state", &PeerConnectionWrap::State),
-      InstanceMethod("createOffer", &PeerConnectionWrap::CreateOffer),
-      InstanceMethod("createAnswer", &PeerConnectionWrap::CreateAnswer),
-      InstanceMethod("setRemoteDescription",
-                     &PeerConnectionWrap::SetRemoteDescription),
-      InstanceMethod("close", &PeerConnectionWrap::Close),
-      InstanceMethod("onStateChange", &PeerConnectionWrap::OnStateChange),
-      InstanceMethod("createDataChannel", &PeerConnectionWrap::CreateDataChannel),
-      InstanceMethod("onDataChannel", &PeerConnectionWrap::OnDataChannel),
-      InstanceMethod("addTrack", &PeerConnectionWrap::AddTrack),
-    });
-    return func;
-  }
-
-  PeerConnectionWrap(const Napi::CallbackInfo& info)
-      : Napi::ObjectWrap<PeerConnectionWrap>(info) {
-    Napi::Env env = info.Env();
-    if (!info[0].IsObject()) {
-      throw TypeError::New(env, "config object required");
-    }
-    Object config = info[0].As<Object>();
-    rtc::Configuration rtcConfig;
-    if (config.Has("iceServers")) {
-      Array servers = config.Get("iceServers").As<Array>();
-      for (uint32_t i = 0; i < servers.Length(); i++) {
-        std::string url = servers.Get(i).As<String>().Utf8Value();
-        rtcConfig.iceServers.emplace_back(url);
-      }
-    }
-    pc_ = std::make_shared<rtc::PeerConnection>(rtcConfig);
-
-    // IMPORTANT: register description/gathering callbacks HERE (constructor),
-    // BEFORE any createDataChannel call. libdatachannel only fires
-    // onLocalDescription for negotiations that start AFTER the callback is
-    // registered — if createDataChannel runs first, the offer callback never
-    // fires (verified in C++ spike: test3 vs test2).
-    pc_->onLocalDescription([this](rtc::Description desc) {
-      latestLocalDesc_ = std::string(desc);
-      fprintf(stderr, "[binding] trickle desc, %zu bytes\n",
-              latestLocalDesc_.size());
-    });
-    pc_->onGatheringStateChange([this](rtc::PeerConnection::GatheringState gs) {
-      fprintf(stderr, "[binding] gathering state: %d\n", (int)gs);
-      if (gs == rtc::PeerConnection::GatheringState::Complete) {
-        // Use the getter — it returns the FULL SDP including candidates after
-        // gathering (trickle callbacks only carry the initial fragment).
-        auto ld = pc_->localDescription();
-        if (ld) {
-          latestLocalDesc_ = std::string(*ld);
-          fprintf(stderr, "[binding] final desc, %zu bytes\n",
-                  latestLocalDesc_.size());
-        }
-        resolvePendingLocalDesc_();
-      }
-    });
-  }
-
- private:
-  std::shared_ptr<rtc::PeerConnection> pc_;
-  std::shared_ptr<ThreadSafeFunction> stateCb_;
-  std::shared_ptr<ThreadSafeFunction> dcCb_;
-  std::string latestLocalDesc_;
-  std::shared_ptr<DeferredHolder> pendingDescDeferred_;
-  std::shared_ptr<ThreadSafeFunction> pendingDescTsfn_;
-
-  void resolvePendingLocalDesc_() {
-    if (!pendingDescDeferred_ || !pendingDescTsfn_) return;
-    auto holder = pendingDescDeferred_;
-    auto tsfn = pendingDescTsfn_;
-    pendingDescDeferred_.reset();
-    pendingDescTsfn_.reset();
-    std::string sdp = latestLocalDesc_;
-    tsfn->BlockingCall([sdp, holder](Napi::Env e, Function) {
-      holder->deferred.Resolve(String::New(e, sdp));
-    });
-  }
-
-  Napi::Value State(const Napi::CallbackInfo& info) {
-    return String::New(info.Env(),
-                       pc_ ? stateToString(pc_->state()) : "closed");
-  }
-
-  // createOffer() -> Promise<string> — sets local description, waits for
-  // ICE gathering to complete (so candidates are in the SDP), resolves SDP.
-  Napi::Value CreateOffer(const Napi::CallbackInfo& info) {
-    Napi::Env env = info.Env();
-    auto holder = std::make_shared<DeferredHolder>(Promise::Deferred::New(env));
-    if (!pc_) {
-      holder->deferred.Reject(Error::New(env, "peer closed").Value());
-      return holder->deferred.Promise();
-    }
-    // createDataChannel already triggers negotiation in libdatachannel 0.24 —
-    // if gathering already completed, resolve immediately from the cached SDP.
-    if (!latestLocalDesc_.empty()) {
-      auto tsfn = std::make_shared<ThreadSafeFunction>(ThreadSafeFunction::New(
-          env, Function::New(env, [](const CallbackInfo&) {}), "desc", 0, 1));
-      std::string sdp = latestLocalDesc_;
-      tsfn->BlockingCall([sdp, holder](Napi::Env e, Function) {
-        holder->deferred.Resolve(String::New(e, sdp));
-      });
-      return holder->deferred.Promise();
-    }
-    if (pendingDescDeferred_) {
-      pendingDescDeferred_->deferred.Reject(
-          Error::New(env, "previous negotiation still pending").Value());
-    }
-    pendingDescDeferred_ = holder;
-    pendingDescTsfn_ = std::make_shared<ThreadSafeFunction>(
-        ThreadSafeFunction::New(env, Function::New(env, [](const CallbackInfo&) {}),
-                                "desc", 0, 1));
-    fprintf(stderr, "[binding] calling setLocalDescription(Offer)\n");
-    try {
-      pc_->setLocalDescription(rtc::Description::Type::Offer);
-      fprintf(stderr, "[binding] setLocalDescription returned OK\n");
-    } catch (const std::exception& e) {
-      pendingDescDeferred_.reset();
-      fprintf(stderr, "[binding] setLocalDescription THREW: %s\n", e.what());
-      throw Error::New(env, e.what());
-    }
-    return holder->deferred.Promise();
-  }
-
-  // createAnswer(offerSdp: string) -> Promise<string>
-  Napi::Value CreateAnswer(const Napi::CallbackInfo& info) {
-    Napi::Env env = info.Env();
-    std::string offer = info[0].As<String>().Utf8Value();
-    auto holder = std::make_shared<DeferredHolder>(Promise::Deferred::New(env));
-    if (!pc_) {
-      holder->deferred.Reject(Error::New(env, "peer closed").Value());
-      return holder->deferred.Promise();
-    }
-    if (pendingDescDeferred_) {
-      pendingDescDeferred_->deferred.Reject(
-          Error::New(env, "previous negotiation still pending").Value());
-    }
-    pendingDescDeferred_ = holder;
-    pendingDescTsfn_ = std::make_shared<ThreadSafeFunction>(
-        ThreadSafeFunction::New(env, Function::New(env, [](const CallbackInfo&) {}),
-                                "desc", 0, 1));
-    try {
-      pc_->setRemoteDescription(
-          rtc::Description(offer, rtc::Description::Type::Offer));
-      fprintf(stderr, "[binding] answer: setRemoteDescription OK\n");
-      // libdatachannel 0.24 AUTO-GENERATES the answer when a remote offer is
-      // applied (verified in C++ spike test8/9: B desc type=Answer fires
-      // immediately with a=setup:active). Calling setLocalDescription() again
-      // would OVERWRITE it with a role=actpass SDP, which A rejects with
-      // "Illegal role actpass in remote answer description". So we do NOT call
-      // setLocalDescription here — we just wait for gathering complete and
-      // resolve with the auto-generated answer. This also matches @dank074's
-      // Discord voice flow.
-    } catch (const std::exception& e) {
-      pendingDescDeferred_.reset();
-      fprintf(stderr, "[binding] answer THREW: %s\n", e.what());
-      holder->deferred.Reject(Error::New(env, e.what()).Value());
-    }
-    return holder->deferred.Promise();
-  }
-
-  void SetRemoteDescription(const Napi::CallbackInfo& info) {
-    std::string sdp = info[0].As<String>().Utf8Value();
-    std::string type = info[1].As<String>().Utf8Value();
-    rtc::Description::Type t = (type == "answer")
-                                   ? rtc::Description::Type::Answer
-                                   : rtc::Description::Type::Offer;
-    if (pc_) pc_->setRemoteDescription(rtc::Description(sdp, t));
-  }
-
-  void Close(const Napi::CallbackInfo& info) {
-    if (pc_) pc_->close();
-  }
-
-  void OnStateChange(const Napi::CallbackInfo& info) {
-    Function cb = info[0].As<Function>();
-    stateCb_ = std::make_shared<ThreadSafeFunction>(
-        ThreadSafeFunction::New(info.Env(), cb, "pc-state", 0, 1));
-    std::shared_ptr<rtc::PeerConnection> pc = pc_;
-    pc->onStateChange([this](rtc::PeerConnection::State state) {
-      if (stateCb_) {
-        std::string s = stateToString(state);
-        stateCb_->BlockingCall([s](Napi::Env env, Function cb) {
-          cb.Call({String::New(env, s)});
-        });
-      }
-    });
-  }
-
-  Napi::Value CreateDataChannel(const Napi::CallbackInfo& info) {
-    Napi::Env env = info.Env();
-    std::string label = info[0].As<String>().Utf8Value();
-    fprintf(stderr, "[binding] createDataChannel(%s)\n", label.c_str());
-    auto dc = pc_->createDataChannel(label);
-    Object obj = DataChannelWrap::NewInstance(env);
-    DataChannelWrap::Unwrap(obj)->Init(dc);
-    return obj;
-  }
-
-  Napi::Value AddTrack(const Napi::CallbackInfo& info) {
-    Napi::Env env = info.Env();
-    std::string mid = info[0].As<String>().Utf8Value();
-    std::string kind = info[1].As<String>().Utf8Value();
-    if (!pc_) throw Error::New(env, "peer closed");
-    fprintf(stderr, "[binding] addTrack(%s, %s) start\n", mid.c_str(), kind.c_str());
-    try {
-      std::shared_ptr<rtc::Track> track;
-      if (kind == "audio") {
-      // Opus payload type 120 (matches @dank074 CodecPayloadType.opus)
-      auto desc = rtc::Description::Audio(mid);
-      desc.addOpusCodec(120);
-      track = pc_->addTrack(desc);
-      } else {
-      // All video codecs with their payload types, matching WebRtcWrapper:
-      // H264 101/102, H265 103/104, VP8 105/106, VP9 107/108, AV1 109/110
-      auto desc = rtc::Description::Video(mid);
-      desc.addH264Codec(101);
-      desc.addRtxCodec(102, 101, 90000);
-      desc.addH265Codec(103);
-      desc.addRtxCodec(104, 103, 90000);
-      desc.addVP8Codec(105);
-      desc.addRtxCodec(106, 105, 90000);
-      desc.addVP9Codec(107);
-      desc.addRtxCodec(108, 107, 90000);
-      desc.addAV1Codec(109);
-      desc.addRtxCodec(110, 109, 90000);
-      track = pc_->addTrack(desc);
-    }
-      Object obj = TrackWrap::NewInstance(env);
-      TrackWrap::Unwrap(obj)->Init(track, env);
-      return obj;
-    } catch (const std::exception& e) {
-      fprintf(stderr, "[binding] addTrack THREW: %s\n", e.what());
-      throw Error::New(env, e.what());
-    }
-  }
-
-  void OnDataChannel(const Napi::CallbackInfo& info) {
-    Function cb = info[0].As<Function>();
-    dcCb_ = std::make_shared<ThreadSafeFunction>(
-        ThreadSafeFunction::New(info.Env(), cb, "dc", 0, 1));
-    std::shared_ptr<rtc::PeerConnection> pc = pc_;
-    pc->onDataChannel([this](std::shared_ptr<rtc::DataChannel> dc) {
-      if (dcCb_) {
-        auto dcPtr = dc;
-        dcCb_->BlockingCall([dcPtr](Napi::Env env, Function cb) {
-          Object obj = DataChannelWrap::NewInstance(env);
-          DataChannelWrap::Unwrap(obj)->Init(dcPtr);
-          cb.Call({obj});
-        });
-      }
-    });
-  }
-};
-
-Object InitAll(Napi::Env env, Object exports) {
-  exports.Set("PeerConnection", PeerConnectionWrap::Init(env));
-  exports.Set("DataChannel", DataChannelWrap::Init(env));
-  exports.Set("Track", TrackWrap::Init(env));
-  return exports;
-}
-
-NODE_API_MODULE(libdatachannel_min, InitAll)
-
-// Definition for the static constructor references.
-FunctionReference DataChannelWrap::dcConstructor;
-FunctionReference TrackWrap::trackConstructor;
-
-}  // namespace

services/discord-gateway/native/libdatachannel-min/binding.gyp

@@ -1,21 +0,0 @@
-{
-  "targets": [
-    {
-      "target_name": "libdatachannel_min",
-      "sources": ["binding.cpp"],
-      "include_dirs": [
-        "<!(node -e \"console.log(process.env.NAPI_INCLUDE || (() => { try { return require('node-addon-api').include; } catch { return '/nonexistent'; } })())\")",
-        "<!(node -e \"const s=process.env.LDC_INCLUDE||'/nix/store/39a85gpfjqy3h3k8jwrwh7m9yc3inqw7-source';console.log(s+'/include')\")"
-      ],
-      "libraries": [
-        "<!(node -e \"console.log(process.env.LDC_LIB || '/tmp/ldc-build/libdatachannel.so.0.24.0')\")"
-      ],
-      "cflags": ["-std=c++17", "-fexceptions"],
-      "cflags_cc": ["-std=c++17", "-fexceptions"],
-      "defines": ["NAPI_CPP_EXCEPTIONS"],
-      "conditions": [
-        ["OS=='linux'", { "cflags": ["-fvisibility=hidden"] }]
-      ]
-    }
-  ]
-}

services/discord-gateway/native/libdatachannel-min/index.js

@@ -1,3 +0,0 @@
-// libdatachannel-min — JS entry.
-const native = require("./build/Release/datachannel_min.node");
-module.exports = native;

services/discord-gateway/native/libdatachannel-min/package.json

@@ -1,17 +0,0 @@
-{
-  "name": "libdatachannel-min",
-  "version": "0.1.0",
-  "description": "Minimal N-API binding to libdatachannel — PeerConnection, DataChannel, ICE, SDP (+ media tracks for GoLive)",
-  "main": "index.js",
-  "gypfile": true,
-  "scripts": {
-    "build": "node-gyp rebuild",
-    "test": "node test-handshake.js"
-  },
-  "dependencies": {
-    "node-addon-api": "^8.3.0"
-  },
-  "devDependencies": {
-    "node-gyp": "^11.5.0"
-  }
-}

services/discord-gateway/native/libdatachannel-min/test-handshake.js

@@ -1,82 +0,0 @@
-// Phase 0 spike: prove the minimal binding can do a full WebRTC handshake
-// (offer/answer + ICE + DataChannel) between two local PeerConnections.
-"use strict";
-const { PeerConnection } = require("./build/Release/datachannel_min.node");
-
-function log(...args) {
-  console.log("[spike]", ...args);
-}
-
-async function main() {
-  const pcA = new PeerConnection({ iceServers: [] });
-  const pcB = new PeerConnection({ iceServers: [] });
-
-  const stateLog = [];
-  pcA.onStateChange((s) => {
-    stateLog.push(`A:${s}`);
-    log("A state:", s);
-  });
-  pcB.onStateChange((s) => {
-    stateLog.push(`B:${s}`);
-    log("B state:", s);
-  });
-
-  // B waits for incoming DataChannel
-  const received = new Promise((resolve) => {
-    pcB.onDataChannel((dc) => {
-      log("B got incoming DataChannel");
-      dc.onOpen(() => log("B DataChannel open"));
-      dc.onMessage((msg) => {
-        log("B received message:", msg);
-        dc.send("pong from B");
-        resolve(msg);
-      });
-    });
-  });
-
-  // A creates an outgoing DataChannel
-  const dcA = pcA.createDataChannel("test");
-  dcA.onOpen(() => {
-    log("A DataChannel open — sending hello");
-    dcA.send("hello from A");
-  });
-  dcA.onMessage((msg) => {
-    log("A received reply:", msg);
-  });
-
-  // Offer/answer dance
-  log("A createOffer...");
-  const offer = await pcA.createOffer();
-  log("Offer SDP bytes:", offer.length);
-  log("B createAnswer...");
-  const answer = await pcB.createAnswer(offer);
-  log("Answer SDP bytes:", answer.length);
-  const setupMatch = answer.match(/a=setup:(\S+)/);
-  log("Answer setup role:", setupMatch ? setupMatch[1] : "NONE");
-  pcA.setRemoteDescription(answer, "answer");
-
-  // Wait for message roundtrip
-  const msg = await Promise.race([
-    received,
-    new Promise((_, rej) => setTimeout(() => rej(new Error("TIMEOUT waiting for datachannel message")), 15000)),
-  ]);
-
-  log("ROUNDTRIP OK — B got:", msg);
-  log("States:", stateLog.join(" | "));
-
-  const aState = pcA.state();
-  const bState = pcB.state();
-  log("Final states — A:", aState, "B:", bState);
-
-  pcA.close();
-  pcB.close();
-
-  if (msg !== "hello from A") throw new Error("wrong message");
-  if (aState !== "connected" && aState !== "disconnected") throw new Error("A not connected: " + aState);
-  log("SPIKE PASSED ✅");
-}
-
-main().catch((e) => {
-  console.error("SPIKE FAILED:", e.message);
-  process.exit(1);
-});

services/discord-gateway/native/libdatachannel-min/test-packetizer.js

@@ -1,80 +0,0 @@
-// Verify setPacketizer + sendFrame: two peers connect, audio+video tracks
-// packetize real encoded frames (opus + AnnexB H264), RTP flows without crash.
-"use strict";
-const { PeerConnection } = require("./build/Release/datachannel_min.node");
-
-function sleep(ms) { return new Promise((r) => setTimeout(r, ms)); }
-
-async function main() {
-  const pcA = new PeerConnection({ iceServers: [] });
-  const pcB = new PeerConnection({ iceServers: [] });
-
-  const aAudio = pcA.addTrack("0", "audio");
-  const aVideo = pcA.addTrack("1", "video");
-  pcB.addTrack("0", "audio");
-  pcB.addTrack("1", "video");
-
-  let states = { a: "", b: "" };
-  pcA.onStateChange((s) => (states.a = s));
-  pcB.onStateChange((s) => (states.b = s));
-
-  // A: offer (createDataChannel not needed — tracks trigger negotiation)
-  const offer = await pcA.createOffer();
-  pcB.setRemoteDescription(offer, "offer");
-  const answer = await pcB.createAnswer(offer);
-  pcA.setRemoteDescription(answer, "answer");
-
-  // Wait for connected
-  for (let i = 0; i < 50; i++) {
-    if (states.a === "connected" && states.b === "connected") break;
-    await sleep(100);
-  }
-  console.log("[pkt] states:", states.a, states.b);
-  if (states.a !== "connected" || states.b !== "connected") {
-    console.log("PKT TEST FAILED: not connected");
-    process.exit(1);
-  }
-
-  // Setup packetizers on A (sender)
-  aAudio.setPacketizer("audio", 1234, 120, 48000, 5, 0, 1);
-  aVideo.setPacketizer("h264", 5678, 101, 90000, 5, 0, 10);
-
-  // Fake opus frame (20ms @48kHz stereo — payload can be any bytes)
-  const opusFrame = Buffer.alloc(160);
-  for (let i = 0; i < 160; i++) opusFrame[i] = i & 0xff;
-
-  // Fake AnnexB H264 frame: SPS + PPS + IDR slice
-  const sps = Buffer.from([0x00, 0x00, 0x00, 0x01, 0x67, 0x42, 0xc0, 0x1e, 0xd9, 0x01, 0x40, 0x7e]);
-  const pps = Buffer.from([0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x3c, 0x80]);
-  const idr = Buffer.from([0x00, 0x00, 0x00, 0x01, 0x65, 0x88, 0x84, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07]);
-  const h264Frame = Buffer.concat([sps, pps, idr]);
-
-  // Send 10 audio frames (20ms each) + 3 video frames (33ms each)
-  for (let i = 0; i < 10; i++) {
-    aAudio.sendFrame(opusFrame);
-    aAudio.addTimestamp(960); // 20ms @ 48kHz
-  }
-  for (let i = 0; i < 3; i++) {
-    aVideo.sendFrame(h264Frame);
-    aVideo.addTimestamp(3000); // 33ms @ 90kHz
-  }
-
-  await sleep(500);
-  console.log("[pkt] after send: states:", states.a, states.b);
-  console.log("[pkt] audio track open:", aAudio.isOpen(), "| video track open:", aVideo.isOpen());
-  const ok = states.a === "connected" && aAudio.isOpen() && aVideo.isOpen();
-  console.log(ok ? "PKT TEST PASSED" : "PKT TEST FAILED");
-  pcA.close();
-  pcB.close();
-  process.exit(ok ? 0 : 1);
-}
-
-main().catch((e) => {
-  console.error("[pkt] FAILED:", e.message);
-  process.exit(1);
-});
-
-setTimeout(() => {
-  console.error("[pkt] TIMEOUT");
-  process.exit(1);
-}, 25000);

services/discord-gateway/native/libdatachannel-min/test-track.js

@@ -1,33 +0,0 @@
-// Verify addTrack produces SDP with audio+video media sections.
-"use strict";
-const { PeerConnection } = require("./build/Release/datachannel_min.node");
-
-const pc = new PeerConnection({ iceServers: [] });
-const audioTrack = pc.addTrack("0", "audio");
-const videoTrack = pc.addTrack("1", "video");
-
-pc.onStateChange((s) => console.log("[test-track] state:", s));
-
-pc.createOffer().then((sdp) => {
-  const hasAudio = /^m=audio\s/m.test(sdp);
-  const hasVideo = /^m=video\s/m.test(sdp);
-  const audioPts = sdp.match(/a=rtpmap:(\d+) opus/g) || [];
-  const videoPts = sdp.match(/a=rtpmap:(\d+) H264/g) || [];
-  console.log("[test-track] SDP bytes:", sdp.length);
-  console.log("[test-track] m=audio:", hasAudio, "| m=video:", hasVideo);
-  console.log("[test-track] opus pt:", audioPts, "| H264 pt:", videoPts);
-  console.log("[test-track] audio track send ok:", typeof audioTrack.send === "function");
-  console.log("[test-track] video track send ok:", typeof videoTrack.send === "function");
-  const ok = hasAudio && hasVideo && audioPts.length > 0 && videoPts.length > 0;
-  console.log(ok ? "TRACK TEST PASSED" : "TRACK TEST FAILED");
-  pc.close();
-  process.exit(ok ? 0 : 1);
-}).catch((e) => {
-  console.error("[test-track] FAILED:", e.message);
-  process.exit(1);
-});
-
-setTimeout(() => {
-  console.error("[test-track] TIMEOUT");
-  process.exit(1);
-}, 20000);

services/discord-gateway/package.json

@@ -28,7 +28,6 @@
     "discord.js-selfbot-v13": "^3.7.1",
     "dotenv": "^17.4.2",
     "drizzle-orm": "^0.45.2",
-    "imghash": "^1.1.4",
     "ioredis": "^5.11.0",
     "libsodium-wrappers": "^0.8.4",
     "lru-cache": "^11.5.1",

services/discord-gateway/src/app/bootstrap.ts

@@ -222,7 +222,10 @@ export async function initializeDiscordGateway() {
     await initializeDatabase();
     logger.info("PostgreSQL database initialized");
   } catch (err) {
-    logger.error({ error: err }, "Failed to initialize database");
+    logger.error(
+      { err, errorMsg: err instanceof Error ? err.message : String(err) },
+      "Failed to initialize database",
+    );
     throw new DatabaseError(
       `Database initialization failed: ${err instanceof Error ? err.message : String(err)}`,
     );
@@ -267,7 +270,10 @@ export async function initializeDiscordGateway() {
   });
 
   client.on("error", (err) => {
-    logger.error({ error: err }, "Client error");
+    logger.error(
+      { err, errorMsg: err instanceof Error ? err.message : String(err) },
+      "Client error",
+    );
   });
 
   process.on("SIGINT", () => {
@@ -298,12 +304,39 @@ export async function initializeDiscordGateway() {
       );
       return;
     }
-    logger.error({ error: err }, "Uncaught exception");
+    logger.error(
+      {
+        err,
+        errorMsg: err instanceof Error ? err.message : String(err),
+        stack: err?.stack,
+      },
+      "Uncaught exception",
+    );
     gracefulShutdown("uncaughtException");
   });
 
-  process.on("unhandledRejection", (reason, promise) => {
-    logger.error({ reason, promise }, "Unhandled rejection");
+  process.on("unhandledRejection", (reason) => {
+    const err =
+      reason instanceof Error ? reason : new Error(String(reason ?? "unknown"));
+    const code = (err as NodeJS.ErrnoException).code ?? "";
+    // Same transient-teardown policy as uncaughtException: a rejection that
+    // fires while a stream is being torn down (EPIPE after ffmpeg stdin
+    // closes, write-after-destroy, socket reset) must NOT take the whole
+    // gateway offline. Log detail + continue. Everything else still shuts
+    // down so real bugs surface.
+    if (
+      code === "EPIPE" ||
+      code === "ERR_STREAM_DESTROYED" ||
+      code === "ERR_STREAM_WRITE_AFTER_END" ||
+      code === "ECONNRESET"
+    ) {
+      logger.warn(
+        { error: err },
+        "Unhandled rejection transient stream error — continuing",
+      );
+      return;
+    }
+    logger.error({ error: err, reason: String(reason) }, "Unhandled rejection");
     gracefulShutdown("unhandledRejection");
   });
 

services/discord-gateway/src/goLive/AnnexBBitstreamReaderWriter.ts

@@ -1,155 +0,0 @@
-/**
- * AnnexB bitstream reader/writer (RBSP + emulation prevention) — ported
- * from @dank074/discord-video-stream AnnexBBitstreamReaderWriter.js.
- */
-
-export class AnnexBBitstreamReader {
-  private _buffer: Uint8Array;
-  private _byteOffset = 0;
-  private _bitOffset = 0;
-
-  constructor(buffer: Uint8Array) {
-    this._buffer = buffer;
-  }
-
-  readBits(count: number): number {
-    if (count === 0) return 0;
-    let result = 0;
-    while (count > 0) {
-      if (this._byteOffset >= this._buffer.length) {
-        throw new Error("Bad byte offset");
-      }
-      if (
-        this._bitOffset === 0 &&
-        this._byteOffset >= 2 &&
-        this._buffer[this._byteOffset - 2] === 0 &&
-        this._buffer[this._byteOffset - 1] === 0 &&
-        this._buffer[this._byteOffset] === 3
-      ) {
-        // Skip over emulation prevention
-        this._byteOffset++;
-      }
-      if (this._bitOffset === 0 && count >= 8) {
-        result = (result << 8) | this._buffer[this._byteOffset++];
-        count -= 8;
-      } else {
-        const numBitsToRead = Math.min(count, 8 - this._bitOffset);
-        const mask = (1 << numBitsToRead) - 1;
-        const newBits =
-          (this._buffer[this._byteOffset] >>
-            (8 - this._bitOffset - numBitsToRead)) &
-          mask;
-        result = (result << numBitsToRead) | newBits;
-        count -= numBitsToRead;
-        this._bitOffset += numBitsToRead;
-        if (this._bitOffset === 8) {
-          this._bitOffset = 0;
-          this._byteOffset++;
-        }
-      }
-    }
-    return result;
-  }
-
-  readUnsigned(bits: number): number {
-    return this.readBits(bits);
-  }
-
-  readSigned(bits: number): number {
-    const unsigned = this.readUnsigned(bits);
-    if (unsigned & (1 << (bits - 1))) return unsigned - (1 << bits);
-    return unsigned;
-  }
-
-  readUnsignedExpGolomb(): number {
-    let leading0 = 0;
-    while (this.readBits(1) === 0) leading0++;
-    return (1 << leading0) + this.readBits(leading0) - 1;
-  }
-
-  readSignedExpGolomb(): number {
-    const unsigned = this.readUnsignedExpGolomb();
-    if (unsigned % 2 === 0) return unsigned / -2;
-    return (unsigned + 1) / 2;
-  }
-}
-
-export class AnnexBBitstreamWriter {
-  private _arr: number[] = [];
-  private _pendingByte = 0;
-  private _bitOffset = 0;
-
-  toBuffer(): Buffer {
-    return Buffer.from(this._arr);
-  }
-
-  flush(): void {
-    // Emulation prevention: insert 0x03 before 00 00
-    if (
-      this._pendingByte <= 3 &&
-      this._arr[this._arr.length - 1] === 0 &&
-      this._arr[this._arr.length - 2] === 0
-    ) {
-      this._arr.push(3);
-    }
-    this._arr.push(this._pendingByte);
-    this._pendingByte = 0;
-    this._bitOffset = 0;
-  }
-
-  writeBits(bits: number, count: number): void {
-    while (count > 0) {
-      if (this._bitOffset === 0) {
-        if (count >= 8) {
-          this._pendingByte = (bits >> (count - 8)) & 0xff;
-          count -= 8;
-          this.flush();
-        } else {
-          const mask = (1 << count) - 1;
-          this._pendingByte |= (bits & mask) << (8 - count);
-          this._bitOffset = count;
-          count = 0;
-        }
-      } else {
-        const numBitsToWrite = Math.min(8 - this._bitOffset, count);
-        const bitsToWrite =
-          (bits >> (count - numBitsToWrite)) & ((1 << numBitsToWrite) - 1);
-        this._pendingByte |=
-          bitsToWrite << (8 - this._bitOffset - numBitsToWrite);
-        count -= numBitsToWrite;
-        this._bitOffset += numBitsToWrite;
-        if (this._bitOffset === 8) {
-          this._bitOffset = 0;
-          this.flush();
-        }
-      }
-    }
-  }
-
-  writeUnsigned(num: number, count: number): void {
-    if (num < 0) throw new Error("Expected a non-negative number");
-    this.writeBits(num, count);
-  }
-
-  writeSigned(num: number, count: number): void {
-    if (count <= 0) return;
-    if (count > 32) throw new Error("writeSigned supports up to 32 bits");
-    const mask =
-      count === 32 ? 0xffffffff >>> 0 : (((1 << count) >>> 0) - 1) >>> 0;
-    const unsigned = (num & mask) >>> 0;
-    this.writeBits(unsigned, count);
-  }
-
-  writeUnsignedExpGolomb(num: number): void {
-    if (num < 0) throw new Error("Expected a non-negative number");
-    num++;
-    const bitCount = 32 - Math.clz32(num >>> 0);
-    this.writeBits(0, bitCount - 1);
-    this.writeBits(num, bitCount);
-  }
-
-  writeSignedExpGolomb(num: number): void {
-    if (num < 0) this.writeUnsignedExpGolomb(-2 * num);
-    else this.writeUnsignedExpGolomb(2 * num - 1);
-  }
-}

services/discord-gateway/src/goLive/AnnexBHelper.ts

@@ -1,112 +0,0 @@
-/**
- * H264/H265 NAL helpers — ported from @dank074/discord-video-stream
- * AnnexBHelper.js. Only the H264 parts are used by GoLive (H264 encoder),
- * H265 constants kept for completeness of the port.
- */
-
-export enum H264NalUnitTypes {
-  Unspecified = 0,
-  CodedSliceNonIDR = 1,
-  CodedSlicePartitionA = 2,
-  CodedSlicePartitionB = 3,
-  CodedSlicePartitionC = 4,
-  CodedSliceIdr = 5,
-  SEI = 6,
-  SPS = 7,
-  PPS = 8,
-  AccessUnitDelimiter = 9,
-  EndOfSequence = 10,
-  EndOfStream = 11,
-  FillerData = 12,
-  SEIExtenstion = 13,
-  PrefixNalUnit = 14,
-  SubsetSPS = 15,
-}
-
-export enum H265NalUnitTypes {
-  TRAIL_N = 0,
-  TRAIL_R = 1,
-  TSA_N = 2,
-  TSA_R = 3,
-  STSA_N = 4,
-  STSA_R = 5,
-  RADL_N = 6,
-  RADL_R = 7,
-  RASL_N = 8,
-  RASL_R = 9,
-  RSV_VCL_N10 = 10,
-  RSV_VCL_R11 = 11,
-  RSV_VCL_N12 = 12,
-  RSV_VCL_R13 = 13,
-  RSV_VCL_N14 = 14,
-  RSV_VCL_R15 = 15,
-  BLA_W_LP = 16,
-  BLA_W_RADL = 17,
-  BLA_N_LP = 18,
-  IDR_W_RADL = 19,
-  IDR_N_LP = 20,
-  CRA_NUT = 21,
-  RSV_IRAP_VCL22 = 22,
-  RSV_IRAP_VCL23 = 23,
-  RSV_VCL24 = 24,
-  RSV_VCL25 = 25,
-  RSV_VCL26 = 26,
-  RSV_VCL27 = 27,
-  RSV_VCL28 = 28,
-  RSV_VCL29 = 29,
-  RSV_VCL30 = 30,
-  RSV_VCL31 = 31,
-  VPS_NUT = 32,
-  SPS_NUT = 33,
-  PPS_NUT = 34,
-  AUD_NUT = 35,
-  EOS_NUT = 36,
-  EOB_NUT = 37,
-  FD_NUT = 38,
-  PREFIX_SEI_NUT = 39,
-  SUFFIX_SEI_NUT = 40,
-}
-
-export const H264Helpers = {
-  getUnitType(frame: Uint8Array): number {
-    return frame[0] & 0x1f;
-  },
-  splitHeader(frame: Uint8Array): [Uint8Array, Uint8Array] {
-    return [frame.subarray(0, 1), frame.subarray(1)];
-  },
-  isAUD(unitType: number): boolean {
-    return unitType === H264NalUnitTypes.AccessUnitDelimiter;
-  },
-};
-
-export const H265Helpers = {
-  getUnitType(frame: Uint8Array): number {
-    return (frame[0] >> 1) & 0x3f;
-  },
-  splitHeader(frame: Uint8Array): [Uint8Array, Uint8Array] {
-    return [frame.subarray(0, 2), frame.subarray(2)];
-  },
-  isAUD(unitType: number): boolean {
-    return unitType === H265NalUnitTypes.AUD_NUT;
-  },
-};
-
-export const startCode3 = Buffer.from([0, 0, 1]);
-
-/** Split an AnnexB bitstream into NAL units (start codes stripped). */
-export function splitNalu(buf: Buffer): Buffer[] {
-  let temp: Buffer | null = buf;
-  const nalus: Buffer[] = [];
-  while (temp?.byteLength) {
-    let pos: number = temp.indexOf(startCode3);
-    let length = 3;
-    if (pos > 0 && temp[pos - 1] === 0) {
-      pos--;
-      length++;
-    }
-    const nalu = pos === -1 ? temp : temp.subarray(0, pos);
-    temp = pos === -1 ? null : temp.subarray(pos + length);
-    if (nalu.byteLength) nalus.push(nalu);
-  }
-  return nalus;
-}

services/discord-gateway/src/goLive/AudioStream.ts

@@ -1,20 +0,0 @@
-/**
- * AudioStream — feeds encoded opus frames into the WebRTC connection.
- * Ported from @dank074/discord-video-stream AudioStream.js.
- */
-
-import { BaseMediaStream } from "./BaseMediaStream.js";
-import type { WebRtcConnWrapper } from "./WebRtcWrapper.js";
-
-export class AudioStream extends BaseMediaStream {
-  _conn: WebRtcConnWrapper;
-
-  constructor(conn: WebRtcConnWrapper, noSleep = false) {
-    super("audio", noSleep);
-    this._conn = conn;
-  }
-
-  async _sendFrame(frame: Buffer, frametime: number): Promise<void> {
-    this._conn.sendAudioFrame(frame, frametime);
-  }
-}

services/discord-gateway/src/goLive/BaseMediaConnection.ts

@@ -1,601 +0,0 @@
-/**
- * Base media connection for Discord GoLive — ported from
- * @dank074/discord-video-stream BaseMediaConnection.js.
- *
- * Owns the voice WebSocket (identify/select_protocol/heartbeat/resume),
- * SDP negotiation against Discord's media server, DAVE E2E voice
- * (via @snazzah/davey), and speaking/video attribute signaling.
- */
-
-import { randomUUID } from "node:crypto";
-import { EventEmitter } from "node:events";
-import Davey from "@snazzah/davey";
-import { CodecPayloadType } from "./CodecPayloadType.js";
-import type { NativePeerConnection } from "./native.js";
-import { isNativeAvailable } from "./native.js";
-import { STREAMS_SIMULCAST } from "./utils.js";
-import { VoiceOpCodes, VoiceOpCodesBinary } from "./VoiceOpCodes.js";
-import { WebRtcConnWrapper } from "./WebRtcWrapper.js";
-
-export interface MediaConnectionStatus {
-  hasSession: boolean;
-  hasToken: boolean;
-  started: boolean;
-  resuming: boolean;
-}
-
-export interface VideoAttribute {
-  fps: number;
-  width: number;
-  height: number;
-}
-
-export interface StreamerLike {
-  opts: Record<string, unknown>;
-}
-
-export class BaseMediaConnection extends EventEmitter {
-  interval: ReturnType<typeof setInterval> | null = null;
-  guildId: string | null = null;
-  channelId: string;
-  botId: string;
-  ws: WebSocket | null = null;
-  status: MediaConnectionStatus;
-  server: string | null = null; // websocket url
-  token: string | null = null;
-  session_id: string | null = null;
-  protected _webRtcWrapper: WebRtcConnWrapper;
-  _webRtcParams: {
-    address: string;
-    port: number;
-    audioSsrc: number;
-    videoSsrc: number;
-    rtxSsrc: number;
-    supportedEncryptionModes: string[];
-  } | null = null;
-  protected _closed = false;
-  ready: ((conn: WebRtcConnWrapper) => void) | null;
-  protected _streamer: StreamerLike;
-  protected _sequenceNumber = -1;
-  protected _daveSession: Davey.DAVESession | null = null;
-  protected _connectedUsers = new Set<string>();
-  protected _daveProtocolVersion = 0;
-  protected _davePendingTransitions = new Map<number, number>();
-  protected _daveDowngraded = false;
-
-  constructor(
-    streamer: StreamerLike,
-    guildId: string | null,
-    botId: string,
-    channelId: string,
-    callback: ((conn: WebRtcConnWrapper) => void) | null,
-  ) {
-    super();
-    this._streamer = streamer;
-    this.status = {
-      hasSession: false,
-      hasToken: false,
-      started: false,
-      resuming: false,
-    };
-    this.guildId = guildId;
-    this.channelId = channelId;
-    this.botId = botId;
-    this.ready = callback;
-    this._webRtcWrapper = new WebRtcConnWrapper(this);
-  }
-
-  get type(): "guild" | "call" {
-    return this.guildId ? "guild" : "call";
-  }
-
-  get webRtcConn(): WebRtcConnWrapper {
-    return this._webRtcWrapper;
-  }
-
-  get webRtcParams(): BaseMediaConnection["_webRtcParams"] {
-    return this._webRtcParams;
-  }
-
-  get streamer(): StreamerLike {
-    return this._streamer;
-  }
-
-  /** daveChannelId — overridden in VoiceConnection (channelId) and StreamConnection (serverId - 1n). */
-  get daveChannelId(): string {
-    throw new Error("daveChannelId not implemented");
-  }
-
-  stop(): void {
-    this._closed = true;
-    this._webRtcWrapper.close();
-    this.ws?.close();
-  }
-
-  setSession(session_id: string): void {
-    this.session_id = session_id;
-    this.status.hasSession = true;
-    this.start();
-  }
-
-  setTokens(server: string, token: string): void {
-    this.token = token;
-    this.server = server;
-    this.status.hasToken = true;
-    this.start();
-  }
-
-  start(): void {
-    if (this.status.hasSession && this.status.hasToken) {
-      if (this.status.started) return;
-      this.status.started = true;
-      this.ws = new WebSocket(`wss://${this.server}/?v=8`);
-      this.ws.binaryType = "arraybuffer";
-      this.ws.addEventListener("open", () => {
-        if (this.status.resuming) {
-          this.status.resuming = false;
-          this.resume();
-        } else {
-          this.identify();
-        }
-      });
-      this.ws.addEventListener("error", (err) => {
-        console.error(err);
-      });
-      this.ws.addEventListener("close", (e) => {
-        const wasStarted = this.status.started;
-        this.interval && clearInterval(this.interval);
-        this.status.started = false;
-        const canResume = e.code === 4015 || e.code < 4000;
-        if (canResume && wasStarted) {
-          this.status.resuming = true;
-          this.start();
-        } else {
-          this._closed = true;
-          this._webRtcWrapper?.close();
-        }
-      });
-      this.setupEvents();
-    }
-  }
-
-  handleReady(d: {
-    ip: string;
-    port: number;
-    ssrc: number;
-    streams: { ssrc: number; rtx_ssrc: number }[];
-    modes: string[];
-  }): void {
-    // we hardcoded STREAMS_SIMULCAST, which will always be array of 1
-    const stream = d.streams[0];
-    this._webRtcParams = {
-      address: d.ip,
-      port: d.port,
-      audioSsrc: d.ssrc,
-      videoSsrc: stream.ssrc,
-      rtxSsrc: stream.rtx_ssrc,
-      supportedEncryptionModes: d.modes,
-    };
-  }
-
-  async handleProtocolAck(d: {
-    sdp?: string;
-    dave_protocol_version?: number;
-  }): Promise<void> {
-    if (!("sdp" in d)) throw new Error("Only WebRTC connections are allowed");
-    this._daveProtocolVersion = d.dave_protocol_version ?? 0;
-    this.initDave();
-    // Discord's SDP is garbage — generate our own from its pieces
-    let ip = "";
-    let port = "";
-    let iceUsername = "";
-    let icePassword = "";
-    let fingerprint = "";
-    let candidate = "";
-    for (const line of (d.sdp ?? "").split("\n")) {
-      if (line.startsWith("c=")) ip = line;
-      else if (line.startsWith("a=rtcp")) port = line.split(":")[1];
-      else if (line.startsWith("a=ice-ufrag")) iceUsername = line;
-      else if (line.startsWith("a=ice-pwd")) icePassword = line;
-      else if (line.startsWith("a=fingerprint")) fingerprint = line;
-      else if (line.startsWith("a=candidate")) candidate = line;
-    }
-    const audioPayloadType = CodecPayloadType.opus.payload_type;
-    const audioSection = `
-m=audio ${port} UDP/TLS/RTP/SAVPF ${audioPayloadType}
-${ip}
-a=extmap:1 urn:ietf:params:rtp-hdrext:ssrc-audio-level
-a=extmap:3 http://www.ietf.org/id/draft-holmer-rmcat-transport-wide-cc-extensions-01
-a=setup:passive
-a=mid:0
-a=maxptime:60
-a=inactive
-${iceUsername}
-${icePassword}
-${fingerprint}
-${candidate}
-a=rtcp-mux
-a=rtpmap:${audioPayloadType} opus/48000/2
-a=fmtp:${audioPayloadType} minptime=10;useinbandfec=1;usedtx=1
-a=rtcp-fb:${audioPayloadType} transport-cc
-a=rtcp-fb:${audioPayloadType} nack
-a=ice-lite
-`.trim();
-    const videoPayloads = Object.values(CodecPayloadType).filter(
-      (el) => el.type === "video",
-    );
-    const videoPayloadTypes = videoPayloads.flatMap((el) => [
-      el.payload_type,
-      el.rtx_payload_type ?? 0,
-    ]);
-    const videoSection = `
-m=video ${port} UDP/TLS/RTP/SAVPF ${videoPayloadTypes.join(" ")}
-${ip}
-a=extmap:2 http://www.webrtc.org/experiments/rtp-hdrext/abs-send-time
-a=extmap:3 http://www.ietf.org/id/draft-holmer-rmcat-transport-wide-cc-extensions-01
-a=extmap:14 urn:ietf:params:rtp-hdrext:toffset
-a=extmap:13 urn:3gpp:video-orientation
-a=extmap:5 http://www.webrtc.org/experiments/rtp-hdrext/playout-delay
-a=setup:passive
-a=mid:1
-a=inactive
-${iceUsername}
-${icePassword}
-${fingerprint}
-${candidate}
-a=rtcp-mux
-a=ice-lite
-`.trim();
-    const videoRtpMap = videoPayloads
-      .flatMap((el) => [
-        `a=rtpmap:${el.payload_type} ${el.name}/90000`,
-        `a=rtpmap:${el.rtx_payload_type} rtx/90000`,
-        `a=fmtp:${el.rtx_payload_type} apt=${el.payload_type}`,
-        `a=rtcp-fb:${el.payload_type} ccm fir`,
-        `a=rtcp-fb:${el.payload_type} nack`,
-        `a=rtcp-fb:${el.payload_type} nack pli`,
-        `a=rtcp-fb:${el.payload_type} goog-remb`,
-        `a=rtcp-fb:${el.payload_type} transport-cc`,
-      ])
-      .join("\n");
-    this._webRtcWrapper.webRtcConn?.setRemoteDescription(
-      [audioSection, videoSection, videoRtpMap].join("\n"),
-      "answer",
-    );
-    console.log(
-      `[goLive:${this.constructor.name}] SELECT_PROTOCOL_ACK processed — remote answer set (${[audioSection, videoSection].join("\n").length}B)`,
-    );
-    this.emit("select_protocol_ack");
-  }
-
-  initDave(): void {
-    if (this._daveProtocolVersion) {
-      if (this._daveSession) {
-        this._daveSession.reinit(
-          this._daveProtocolVersion,
-          this.botId,
-          this.daveChannelId,
-        );
-      } else {
-        this._daveSession = new Davey.DAVESession(
-          this._daveProtocolVersion,
-          this.botId,
-          this.daveChannelId,
-        );
-      }
-      this.sendOpcodeBinary(
-        VoiceOpCodesBinary.MLS_KEY_PACKAGE,
-        this._daveSession.getSerializedKeyPackage(),
-      );
-    } else if (this._daveSession) {
-      this._daveSession.reset();
-      this._daveSession.setPassthroughMode(true, 10);
-    }
-  }
-
-  processInvalidCommit(transitionId: number): void {
-    this.sendOpcode(VoiceOpCodes.MLS_INVALID_COMMIT_WELCOME, {
-      transition_id: transitionId,
-    });
-    this.initDave();
-  }
-
-  executePendingTransition(transitionId: number): void {
-    const newVersion = this._davePendingTransitions.get(transitionId);
-    if (newVersion === undefined) {
-      console.error("Unrecognized transition ID", { transitionId });
-      return;
-    }
-    const oldVersion = this._daveProtocolVersion;
-    this._daveProtocolVersion = newVersion;
-    if (oldVersion !== newVersion && newVersion === 0) {
-      // Downgraded
-      this._daveDowngraded = true;
-    } else if (transitionId > 0 && this._daveDowngraded) {
-      this._daveDowngraded = false;
-      this._daveSession?.setPassthroughMode(true, 10);
-    }
-    this._davePendingTransitions.delete(transitionId);
-  }
-
-  setupEvents(): void {
-    this.ws?.addEventListener("message", async (e) => {
-      if (e.data instanceof ArrayBuffer) {
-        this.handleBinaryMessages(Buffer.from(e.data));
-        return;
-      }
-      const { op, d, seq } = JSON.parse(e.data as string) as {
-        op: number;
-        // biome-ignore lint/suspicious/noExplicitAny: Discord voice WS payload is dynamically typed
-        d: any;
-        seq?: number;
-      };
-      if (seq) this._sequenceNumber = seq;
-      if (op === VoiceOpCodes.READY) {
-        this.handleReady(d);
-        this.setProtocols().then(() => this.ready?.(this._webRtcWrapper));
-        this.setVideoAttributes(false);
-      } else if (op >= 4000) {
-        console.error(`${this.constructor.name} connection error`, d);
-      } else if (op === VoiceOpCodes.HELLO) {
-        this.setupHeartbeat(d.heartbeat_interval);
-      } else if (op === VoiceOpCodes.SELECT_PROTOCOL_ACK) {
-        await this.handleProtocolAck(d);
-      } else if (op === VoiceOpCodes.SPEAKING) {
-        // ignore speaking updates
-      } else if (op === VoiceOpCodes.HEARTBEAT_ACK) {
-        // ignore heartbeat acknowledgements
-      } else if (op === VoiceOpCodes.RESUMED) {
-        this.status.started = true;
-      } else if (op === VoiceOpCodes.CLIENTS_CONNECT) {
-        d.user_ids.forEach((id: string) => {
-          this._connectedUsers.add(id);
-        });
-      } else if (op === VoiceOpCodes.CLIENT_DISCONNECT) {
-        this._connectedUsers.delete(d.user_id);
-      } else if (op === VoiceOpCodes.DAVE_PREPARE_TRANSITION) {
-        this._davePendingTransitions.set(d.transition_id, d.protocol_version);
-        if (d.transition_id === 0) {
-          this.executePendingTransition(d.transition_id);
-        } else {
-          if (d.protocol_version === 0) {
-            this._daveSession?.setPassthroughMode(true, 120);
-          }
-          this.sendOpcode(VoiceOpCodes.DAVE_TRANSITION_READY, {
-            transition_id: d.transition_id,
-          });
-        }
-      } else if (op === VoiceOpCodes.DAVE_EXECUTE_TRANSITION) {
-        this.executePendingTransition(d.transition_id);
-      } else if (op === VoiceOpCodes.DAVE_PREPARE_EPOCH) {
-        if (d.epoch === 1) {
-          this._daveProtocolVersion = d.protocol_version;
-          this.initDave();
-        }
-      }
-    });
-  }
-
-  handleBinaryMessages(msg: Buffer): void {
-    this._sequenceNumber = msg.readUint16BE(0);
-    const op = msg.readUint8(2);
-    switch (op) {
-      case VoiceOpCodesBinary.MLS_EXTERNAL_SENDER: {
-        this._daveSession?.setExternalSender(msg.subarray(3));
-        break;
-      }
-      case VoiceOpCodesBinary.MLS_PROPOSALS: {
-        const optype = msg.readUint8(3);
-        if (!this._daveSession) break;
-        const { commit, welcome } = this._daveSession.processProposals(
-          optype,
-          msg.subarray(4),
-          [...this._connectedUsers],
-        );
-        if (commit) {
-          this.sendOpcodeBinary(
-            VoiceOpCodesBinary.MLS_COMMIT_WELCOME,
-            welcome ? Buffer.concat([commit, welcome]) : commit,
-          );
-        }
-        break;
-      }
-      case VoiceOpCodesBinary.MLS_ANNOUNCE_COMMIT_TRANSITION: {
-        const transitionId = msg.readUInt16BE(3);
-        try {
-          this._daveSession?.processCommit(msg.subarray(5));
-          if (transitionId) {
-            this._davePendingTransitions.set(
-              transitionId,
-              this._daveProtocolVersion,
-            );
-            this.sendOpcode(VoiceOpCodes.DAVE_TRANSITION_READY, {
-              transition_id: transitionId,
-            });
-          }
-        } catch (e) {
-          console.debug("MLS commit errored", e);
-          this.processInvalidCommit(transitionId);
-        }
-        break;
-      }
-      case VoiceOpCodesBinary.MLS_WELCOME: {
-        const transitionId = msg.readUInt16BE(3);
-        try {
-          this._daveSession?.processWelcome(msg.subarray(5));
-          if (transitionId) {
-            this._davePendingTransitions.set(
-              transitionId,
-              this._daveProtocolVersion,
-            );
-            this.sendOpcode(VoiceOpCodes.DAVE_TRANSITION_READY, {
-              transition_id: transitionId,
-            });
-          }
-        } catch (e) {
-          console.debug("MLS welcome errored", e);
-          this.processInvalidCommit(transitionId);
-        }
-        break;
-      }
-    }
-  }
-
-  get daveReady(): boolean {
-    return !!this._daveProtocolVersion && !!this._daveSession?.ready;
-  }
-
-  get daveSession(): Davey.DAVESession | null {
-    return this._daveSession;
-  }
-
-  setupHeartbeat(interval: number): void {
-    if (this.interval) {
-      clearInterval(this.interval);
-    }
-    this.interval = setInterval(() => {
-      try {
-        this.sendOpcode(VoiceOpCodes.HEARTBEAT, {
-          t: Date.now(),
-          seq_ack: this._sequenceNumber,
-        });
-      } catch {
-        /* ignore */
-      }
-    }, interval);
-  }
-
-  sendOpcode(code: number, data: unknown): void {
-    if (this.ws?.readyState !== WebSocket.OPEN) return;
-    this.ws.send(JSON.stringify({ op: code, d: data }));
-  }
-
-  sendOpcodeBinary(code: number, data: Uint8Array): void {
-    if (this.ws?.readyState !== WebSocket.OPEN) return;
-    const buf = Buffer.allocUnsafe(data.length + 1);
-    buf.writeUInt8(code);
-    Buffer.from(data).copy(buf, 1);
-    this.ws.send(buf);
-  }
-
-  /** serverId — overridden in VoiceConnection (guildId ?? channelId) and StreamConnection (rtc_server_id). */
-  get serverId(): string | null {
-    throw new Error("serverId not implemented");
-  }
-
-  /** identifies with media server with credentials */
-  identify(): void {
-    if (!this.serverId) throw new Error("Server ID is null or empty");
-    if (!this.session_id) throw new Error("Session ID is null or empty");
-    if (!this.token) throw new Error("Token is null or empty");
-    this.sendOpcode(VoiceOpCodes.IDENTIFY, {
-      server_id: this.serverId,
-      user_id: this.botId,
-      session_id: this.session_id,
-      token: this.token,
-      video: true,
-      streams: STREAMS_SIMULCAST,
-      max_dave_protocol_version: Davey.DAVE_PROTOCOL_VERSION ?? 0,
-    });
-  }
-
-  resume(): void {
-    if (!this.serverId) throw new Error("Server ID is null or empty");
-    if (!this.session_id) throw new Error("Session ID is null or empty");
-    if (!this.token) throw new Error("Token is null or empty");
-    this.sendOpcode(VoiceOpCodes.RESUME, {
-      server_id: this.serverId,
-      session_id: this.session_id,
-      token: this.token,
-      seq_ack: this._sequenceNumber,
-    });
-  }
-
-  /** Sets protocols and ip data used for video and audio (vp8 video, opus audio). */
-  async setProtocols(): Promise<void> {
-    if (!this._webRtcParams) throw new Error("WebRTC parameters not set");
-    if (!isNativeAvailable()) {
-      throw new Error(
-        "libdatachannel-min native binding not built — cannot start GoLive",
-      );
-    }
-    const reconnect = () => {
-      const webRtcConn = this._webRtcWrapper.initWebRtc();
-      webRtcConn.onStateChange((state) => {
-        console.log(`[goLive:${this.constructor.name}] pc state => ${state}`);
-        if (state === "closed" && !this._closed) reconnect();
-      });
-      this._webRtcWrapper.onLocalDescription = (sdp) => {
-        const rtc_connection_id = randomUUID();
-        console.log(
-          `[goLive:${this.constructor.name}] sending SELECT_PROTOCOL (offer ${sdp.length}B, rtc_connection_id=${rtc_connection_id.slice(0, 8)})`,
-        );
-        this.sendOpcode(VoiceOpCodes.SELECT_PROTOCOL, {
-          protocol: "webrtc",
-          codecs: Object.values(CodecPayloadType),
-          data: sdp,
-          sdp,
-          rtc_connection_id,
-        });
-      };
-      // createOffer (binding resolves full SDP incl. candidates after gathering)
-      void webRtcConn.createOffer().then((sdp) => {
-        this._webRtcWrapper.onLocalDescription?.(sdp);
-      });
-    };
-    reconnect();
-    return new Promise((resolve) => {
-      this.once("select_protocol_ack", () => resolve());
-    });
-  }
-
-  setVideoAttributes(enabled: boolean, attr?: VideoAttribute): void {
-    if (!this._webRtcParams) throw new Error("WebRTC parameters not set");
-    const { audioSsrc, videoSsrc, rtxSsrc } = this._webRtcParams;
-    if (!enabled) {
-      this.sendOpcode(VoiceOpCodes.VIDEO, {
-        audio_ssrc: audioSsrc,
-        video_ssrc: 0,
-        rtx_ssrc: 0,
-        streams: [],
-      });
-    } else {
-      if (!attr) throw new Error("Need to specify video attributes");
-      this.sendOpcode(VoiceOpCodes.VIDEO, {
-        audio_ssrc: audioSsrc,
-        video_ssrc: videoSsrc,
-        rtx_ssrc: rtxSsrc,
-        streams: [
-          {
-            type: "video",
-            rid: "100",
-            ssrc: videoSsrc,
-            active: true,
-            quality: 100,
-            rtx_ssrc: rtxSsrc,
-            // hardcode the max bitrate because we don't really know anyway
-            max_bitrate: 10000 * 1000,
-            max_framerate: enabled ? attr.fps : 0,
-            max_resolution: {
-              type: "fixed",
-              width: attr.width,
-              height: attr.height,
-            },
-          },
-        ],
-      });
-    }
-  }
-
-  /** Set speaking status */
-  setSpeaking(speaking: boolean): void {
-    if (!this._webRtcParams) throw new Error("WebRTC connection not ready");
-    this.sendOpcode(VoiceOpCodes.SPEAKING, {
-      delay: 0,
-      speaking: speaking ? 1 : 0,
-      ssrc: this._webRtcParams.audioSsrc,
-    });
-  }
-}
-
-export type { NativePeerConnection };

services/discord-gateway/src/goLive/BaseMediaStream.ts

@@ -1,175 +0,0 @@
-/**
- * BaseMediaStream — pacing/sync for GoLive frames. Ported from
- * @dank074/discord-video-stream BaseMediaStream.js, minus node-av's
- * AVFrame (frames are plain objects here) and debug-level (uses the GMW
- * logger instead).
- */
-
-import { Writable } from "node:stream";
-import { setTimeout as sleep } from "node:timers/promises";
-
-export interface GoLiveFrame {
-  data: Buffer | null;
-  pts: number;
-  duration: number;
-  timeBase: { num: number; den: number };
-  free?: () => void;
-}
-
-export class BaseMediaStream extends Writable {
-  _pts: number | undefined;
-  _syncTolerance = 20;
-  _noSleep: boolean;
-  _startTime: number | undefined;
-  _startPts: number | undefined;
-  _sync = true;
-  _syncStream: BaseMediaStream | undefined;
-  _type: string;
-
-  constructor(type: string, noSleep = false) {
-    super({ objectMode: true, highWaterMark: 0 });
-    this._type = type;
-    this._noSleep = noSleep;
-  }
-
-  get sync(): boolean {
-    return this._sync;
-  }
-
-  set sync(val: boolean) {
-    this._sync = val;
-  }
-
-  get syncStream(): BaseMediaStream | undefined {
-    return this._syncStream;
-  }
-
-  set syncStream(stream: BaseMediaStream | undefined) {
-    if (stream !== undefined && this === stream.syncStream) {
-      throw new Error("Cannot sync 2 streams with eachother");
-    }
-    this._syncStream = stream;
-  }
-
-  get noSleep(): boolean {
-    return this._noSleep;
-  }
-
-  set noSleep(val: boolean) {
-    this._noSleep = val;
-    if (!val) this.resetTimingCompensation();
-  }
-
-  get pts(): number | undefined {
-    return this._pts;
-  }
-
-  get syncTolerance(): number {
-    return this._syncTolerance;
-  }
-
-  set syncTolerance(n: number) {
-    if (n < 0) return;
-    this._syncTolerance = n;
-  }
-
-  async _sendFrame(_frame: Buffer, _frametime: number): Promise<void> {
-    throw new Error("Not implemented");
-  }
-
-  ptsDelta(): number | undefined {
-    if (this.pts !== undefined && this.syncStream?.pts !== undefined) {
-      return this.pts - this.syncStream.pts;
-    }
-    return undefined;
-  }
-
-  isAhead(): boolean {
-    const delta = this.ptsDelta();
-    return (
-      this.syncStream?.writableEnded === false &&
-      delta !== undefined &&
-      delta > this.syncTolerance
-    );
-  }
-
-  isBehind(): boolean {
-    const delta = this.ptsDelta();
-    return (
-      this.syncStream?.writableEnded === false &&
-      delta !== undefined &&
-      delta < -this.syncTolerance
-    );
-  }
-
-  resetTimingCompensation(): void {
-    this._startTime = this._startPts = undefined;
-  }
-
-  async _write(
-    frame: GoLiveFrame,
-    _encoding: BufferEncoding,
-    callback: (error?: Error | null) => void,
-  ): Promise<void> {
-    const { data, pts, duration, timeBase } = frame;
-    if (!data) {
-      frame.free?.();
-      callback();
-      return;
-    }
-    const frametime = (Number(duration) / timeBase.den) * timeBase.num * 1000;
-    const start_sendFrame = performance.now();
-    await this._sendFrame(Buffer.from(data), frametime);
-    const end_sendFrame = performance.now();
-    this._pts = (Number(pts) / timeBase.den) * timeBase.num * 1000;
-    this.emit("pts", this._pts);
-    const sendTime = end_sendFrame - start_sendFrame;
-    const ratio = sendTime / frametime;
-    if (ratio > 1) {
-      // Frame takes longer to send than its frametime — warn once per 100
-      if (
-        this._lastWarnedRatio === undefined ||
-        ratio > this._lastWarnedRatio
-      ) {
-        this._lastWarnedRatio = ratio;
-      }
-    }
-    this._startTime ??= start_sendFrame;
-    this._startPts ??= this._pts;
-    const sleepMs = Math.max(
-      0,
-      this._pts -
-        this._startPts +
-        frametime -
-        (end_sendFrame - this._startTime),
-    );
-    if (this._noSleep || sleepMs === 0) {
-      callback(null);
-    } else if (this.sync && this.isBehind()) {
-      // Stream is behind — don't sleep for this frame
-      this.resetTimingCompensation();
-      callback(null);
-    } else if (this.sync && this.isAhead()) {
-      // Stream is ahead — wait until the sync stream catches up
-      do {
-        await sleep(frametime);
-      } while (this.sync && this.isAhead());
-      this.resetTimingCompensation();
-      callback(null);
-    } else {
-      await sleep(sleepMs);
-      callback(null);
-    }
-    frame.free?.();
-  }
-
-  _lastWarnedRatio: number | undefined;
-
-  _destroy(
-    error: Error | null,
-    callback: (error?: Error | null) => void,
-  ): void {
-    super._destroy(error, callback);
-    this.syncStream = undefined;
-  }
-}

services/discord-gateway/src/goLive/CodecPayloadType.ts

@@ -1,71 +0,0 @@
-/** Payload types for Discord GoLive media — ported from @dank074/discord-video-stream. */
-export interface CodecPayloadTypeEntry {
-  name: string;
-  type: "audio" | "video";
-  clockRate: number;
-  priority: number;
-  payload_type: number;
-  rtx_payload_type?: number;
-  encode?: boolean;
-  decode?: boolean;
-}
-
-export const CodecPayloadType: Record<string, CodecPayloadTypeEntry> = {
-  opus: {
-    name: "opus",
-    type: "audio",
-    clockRate: 48000,
-    priority: 1000,
-    payload_type: 120,
-  },
-  H264: {
-    name: "H264",
-    type: "video",
-    clockRate: 90000,
-    priority: 1000,
-    payload_type: 101,
-    rtx_payload_type: 102,
-    encode: true,
-    decode: true,
-  },
-  H265: {
-    name: "H265",
-    type: "video",
-    clockRate: 90000,
-    priority: 1000,
-    payload_type: 103,
-    rtx_payload_type: 104,
-    encode: true,
-    decode: true,
-  },
-  VP8: {
-    name: "VP8",
-    type: "video",
-    clockRate: 90000,
-    priority: 1000,
-    payload_type: 105,
-    rtx_payload_type: 106,
-    encode: true,
-    decode: true,
-  },
-  VP9: {
-    name: "VP9",
-    type: "video",
-    clockRate: 90000,
-    priority: 1000,
-    payload_type: 107,
-    rtx_payload_type: 108,
-    encode: true,
-    decode: true,
-  },
-  AV1: {
-    name: "AV1",
-    type: "video",
-    clockRate: 90000,
-    priority: 1000,
-    payload_type: 109,
-    rtx_payload_type: 110,
-    encode: true,
-    decode: true,
-  },
-};

services/discord-gateway/src/goLive/Demuxer.ts

@@ -1,377 +0,0 @@
-/**
- * Lightweight demuxer — replaces node-av's LibavDemuxer for GoLive.
- *
- * Spawns ffmpeg to remux input into H264 AnnexB on stdout (video only —
- * screen share doesn't need to mux audio into the demuxer; audio goes
- * separately). This replaces the 114MB node-av binary with a plain ffmpeg
- * spawn.
- *
- * Each video "frame" emitted is a complete NAL sequence terminated by a
- * keyframe boundary (IDR). Audio is not extracted here — for GoLive with
- * audio, the NUT mux + full demuxer would be needed; screen share audio is
- * handled via a separate ffmpeg instance (see getDirectScreenInput).
- */
-
-import { spawn } from "node:child_process";
-import { randomUUID } from "node:crypto";
-import { createWriteStream, existsSync, readdirSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { PassThrough } from "node:stream";
-
-/**
- * Resolve ffmpeg/ffprobe binary. Prefers explicit env override, then PATH,
- * then a Nix-store ffmpeg-headless (the GMW flake provides it in the service
- * profile, but dev shells / tests may not have it on PATH).
- */
-function resolveBin(name: "ffmpeg"): string {
-  const override = process.env.FFMPEG_PATH;
-  if (override && existsSync(override)) return override;
-  // Nix store scan: <store>/<hash>-ffmpeg-headless-*/bin/<name>
-  const store = "/nix/store";
-  if (existsSync(store)) {
-    const entries = readdirSync(store);
-    for (const entry of entries) {
-      if (!entry.includes("ffmpeg-headless-")) continue;
-      const candidate = join(store, entry, "bin", name);
-      if (existsSync(candidate)) return candidate;
-    }
-  }
-  return name; // fall back to PATH
-}
-
-const FFMPEG = resolveBin("ffmpeg");
-
-export const AVCodecID = {
-  AV_CODEC_ID_H264: 27,
-  AV_CODEC_ID_HEVC: 173,
-  AV_CODEC_ID_VP8: 139,
-  AV_CODEC_ID_VP9: 167,
-  AV_CODEC_ID_AV1: 225,
-  AV_CODEC_ID_OPUS: 86019,
-} as const;
-export type AVCodecID = (typeof AVCodecID)[keyof typeof AVCodecID];
-
-export const AV_PKT_FLAG_KEY = 1;
-
-export interface Frame {
-  data: Buffer | null;
-  pts: number;
-  duration: number;
-  timeBase: { num: number; den: number };
-  flags: number;
-  streamIndex: number;
-  free(): void;
-}
-
-export interface DemuxedStream {
-  codec: number;
-  codecName: string;
-  width: number;
-  height: number;
-  framerate_num: number;
-  framerate_den: number;
-  sample_rate: number;
-  stream: PassThrough;
-}
-
-/**
- * Probe a media file for stream info using ffmpeg's stderr (the
- * ffmpeg-headless Nix package ships ffmpeg but not ffprobe). Returns
- * stream descriptors in the same shape ffprobe -show_streams would.
- */
-export async function probeStreams(
-  url: string,
-): Promise<Array<Record<string, unknown>>> {
-  return new Promise((resolve, reject) => {
-    const proc = spawn(FFMPEG, [
-      "-hide_banner",
-      "-loglevel",
-      "info",
-      "-i",
-      url,
-      "-f",
-      "null",
-      "-",
-    ]);
-    let stderr = "";
-    proc.stderr.on("data", (d: Buffer) => (stderr += d.toString()));
-    proc.on("close", () => {
-      // Parse "Stream #0:0: Video: h264 (High), yuv420p, 640x360, 30 fps"
-      const streams: Array<Record<string, unknown>> = [];
-      const re = /Stream #0:(\d+): (Video|Audio): ([^,]+)/g;
-      let m: RegExpExecArray | null;
-      // biome-ignore lint/suspicious/noAssignInExpressions: regex loop idiom
-      while ((m = re.exec(stderr)) !== null) {
-        const [full, idx, kind, codecRaw] = m;
-        void full;
-        const codecName = codecRaw.split(" ")[0].toLowerCase();
-        const stream: Record<string, unknown> = {
-          index: Number(idx),
-          codec_type: kind.toLowerCase(),
-          codec_name: codecName,
-          width: 0,
-          height: 0,
-          r_frame_rate: "0/1",
-          sample_rate: 0,
-        };
-        // dimensions: "640x360"
-        const dim = /(\d{2,5})x(\d{2,5})/.exec(stderr.slice(m.index));
-        if (dim) {
-          stream.width = Number(dim[1]);
-          stream.height = Number(dim[2]);
-        }
-        // fps: "30 fps" or "29.97 fps"
-        const fps = /(\d+(?:\.\d+)?) fps/.exec(stderr.slice(m.index));
-        if (fps) {
-          const v = Number(fps[1]);
-          stream.r_frame_rate = `${Math.round(v * 1000)}/1000`;
-        }
-        // sample rate for audio: "48000 Hz"
-        const sr = /(\d+) Hz/.exec(stderr.slice(m.index));
-        if (sr) stream.sample_rate = Number(sr[1]);
-        streams.push(stream);
-      }
-      resolve(streams);
-    });
-    proc.on("error", (err) => reject(err));
-  });
-}
-
-/**
- * Demux input (URL string or readable stream) into video frames on a
- * PassThrough. Uses ffmpeg -f h264 -c copy for video-only AnnexB output.
- * Returns stream info + the video pipe. Audio is not extracted (GoLive
- * screen share sends silence / uses Discord's mixed audio).
- */
-export async function demux(
-  input: string | PassThrough,
-  _opts: { format: string },
-): Promise<{
-  video: DemuxedStream | undefined;
-  audio: DemuxedStream | undefined;
-  close: () => void;
-}> {
-  const _label = randomUUID();
-  const vPipe = new PassThrough({ objectMode: true, highWaterMark: 128 });
-  const aPipe = new PassThrough({ objectMode: true, highWaterMark: 128 });
-
-  // For stream input, spool to a temp file first so ffprobe can inspect it
-  // (ffprobe needs a seekable file; pipes can't be re-read). The stream is
-  // fully consumed before ffmpeg starts — acceptable for screen-share
-  // sources which are already fully buffered by yt-dlp in practice.
-  let spoolPath: string | null = null;
-  const cleanupSpool = () => {
-    if (spoolPath) {
-      import("node:fs").then(({ unlink }) => unlink(spoolPath!, () => {}));
-      spoolPath = null;
-    }
-  };
-
-  let effectiveInput: string;
-  if (typeof input === "string") {
-    effectiveInput = input;
-  } else {
-    spoolPath = join(tmpdir(), `golive-demux-${_label}.h264`);
-    const ws = createWriteStream(spoolPath);
-    await new Promise<void>((resolve, reject) => {
-      input.pipe(ws);
-      input.on("error", reject);
-      ws.on("finish", resolve);
-      ws.on("error", reject);
-    });
-    effectiveInput = spoolPath;
-  }
-
-  // Probe for codec + dimensions
-  let streams: Array<Record<string, unknown>> = [];
-  try {
-    streams = await probeStreams(effectiveInput);
-  } catch (_e) {
-    // probe failed (e.g. raw h264 without container) — infer h264 default
-    streams = [];
-  }
-
-  const v = streams.find((s) => s.codec_type === "video");
-  const a = streams.find((s) => s.codec_type === "audio");
-  let vInfo: DemuxedStream | undefined;
-  let aInfo: DemuxedStream | undefined;
-
-  if (v) {
-    const codecName = (v.codec_name as string) ?? "h264";
-    const rFrame = (v.r_frame_rate as string) ?? "0/1";
-    const [num, den] = rFrame.split("/").map((n) => Number(n));
-    vInfo = {
-      codec:
-        AVCodecID[
-          (codecName.toUpperCase() as keyof typeof AVCodecID) ??
-            "AV_CODEC_ID_H264"
-        ] ?? AVCodecID.AV_CODEC_ID_H264,
-      codecName,
-      width: (v.width as number) ?? 0,
-      height: (v.height as number) ?? 0,
-      framerate_num: num ?? 0,
-      framerate_den: den ?? 1,
-      sample_rate: 0,
-      stream: vPipe,
-    };
-  } else {
-    // Probe failed (e.g. raw AnnexB h264 input) — still emit frames on the
-    // video pipe; playStream infers dimensions from the first frame.
-    vInfo = {
-      codec: AVCodecID.AV_CODEC_ID_H264,
-      codecName: "h264",
-      width: 0,
-      height: 0,
-      framerate_num: 0,
-      framerate_den: 1,
-      sample_rate: 0,
-      stream: vPipe,
-    };
-  }
-
-  if (a) {
-    const codecName = (a.codec_name as string) ?? "opus";
-    aInfo = {
-      codec:
-        AVCodecID[
-          (codecName.toUpperCase() as keyof typeof AVCodecID) ??
-            "AV_CODEC_ID_OPUS"
-        ],
-      codecName,
-      width: 0,
-      height: 0,
-      framerate_num: 0,
-      framerate_den: 0,
-      sample_rate: Number(a.sample_rate) ?? 0,
-      stream: aPipe,
-    };
-  }
-
-  // Spawn ffmpeg — extract raw video (AnnexB for H264) to stdout
-  const args: string[] = [
-    "-hide_banner",
-    "-loglevel",
-    "error",
-    "-i",
-    effectiveInput,
-    "-c:v",
-    "copy",
-    "-an", // no audio in this minimal demuxer
-    "-f",
-    "h264",
-    "pipe:1",
-  ];
-
-  const proc = spawn(FFMPEG, args, { stdio: ["ignore", "pipe", "pipe"] });
-
-  // Scan stdout for NAL units. Each NAL unit (between start codes) is one frame
-  // payload. We emit them individually; the packetizer chain handles FU-A.
-  let videoBuf = Buffer.alloc(0);
-  let frameCount = 0;
-
-  const emitFrame = (nal: Uint8Array, isKeyFrame: boolean) => {
-    vPipe.write({
-      data: Buffer.from(nal),
-      pts: frameCount,
-      duration: 1,
-      timeBase: { num: 1, den: 90000 },
-      flags: isKeyFrame ? AV_PKT_FLAG_KEY : 0,
-      streamIndex: 0,
-      free: () => {},
-    });
-    frameCount++;
-  };
-
-  if (proc.stdout) {
-    proc.stdout.on("data", (chunk: Buffer) => {
-      videoBuf = Buffer.concat([videoBuf, chunk]);
-      // Find start codes (00 00 01 or 00 00 00 01) and split NALs
-      let start = 0;
-      // If buffer starts with zeros, that's the first start code — emit from there
-      while (start < videoBuf.length) {
-        let scPos = -1;
-        for (let i = start + 1; i < videoBuf.length - 2; i++) {
-          if (
-            videoBuf[i] === 0 &&
-            videoBuf[i + 1] === 0 &&
-            videoBuf[i + 2] === 1
-          ) {
-            scPos = i + 3;
-            break;
-          }
-        }
-        if (scPos === -1) break;
-        // Emit the NAL from `start` to `scPos` (but skip the start code bytes at `start`)
-        if (start < scPos) {
-          let nalStart = start;
-          // Skip start code bytes for the NAL itself (00 00 01)
-          if (
-            videoBuf[nalStart] === 0 &&
-            videoBuf[nalStart + 1] === 0 &&
-            videoBuf[nalStart + 2] === 1
-          ) {
-            nalStart += 3;
-          } else if (
-            nalStart + 3 < scPos &&
-            videoBuf[nalStart] === 0 &&
-            videoBuf[nalStart + 1] === 0 &&
-            videoBuf[nalStart + 2] === 0 &&
-            videoBuf[nalStart + 3] === 1
-          ) {
-            nalStart += 4;
-          }
-          const nal = videoBuf.subarray(nalStart, scPos);
-          // Trim trailing zero bytes (from start code overlap)
-          let end = nal.length;
-          while (end > 0 && nal[end - 1] === 0) end--;
-          if (end > 0) {
-            const nalTrimmed = nal.subarray(0, end);
-            const isIdr = (nalTrimmed[0] & 0x1f) === 5; // IDR
-            emitFrame(nalTrimmed, isIdr);
-          }
-        }
-        // Skip the 00 00 01 at scPos-3 to find next
-        start = scPos;
-        // But the next start code needs at least 3 bytes
-        if (start > videoBuf.length - 3) break;
-      }
-      // Keep remaining bytes (potential partial NAL or start code)
-      if (start > 0 && start < videoBuf.length) {
-        videoBuf = videoBuf.subarray(start);
-      } else if (videoBuf.length > 4) {
-        // No full NAL found, but avoid unbounded growth
-        // Keep a sliding window
-        videoBuf = videoBuf.subarray(videoBuf.length - 3);
-      }
-    });
-    proc.stdout.on("end", () => {
-      if (videoBuf.length > 0) {
-        let end = videoBuf.length;
-        while (end > 0 && videoBuf[end - 1] === 0) end--;
-        if (end > 0) emitFrame(videoBuf.subarray(0, end), false);
-      }
-      vPipe.end();
-      aPipe.end();
-    });
-  }
-
-  if (proc.stderr) {
-    proc.stderr.on("data", () => {
-      /* errors swallowed */
-    });
-  }
-  proc.on("close", () => {
-    vPipe.end();
-    aPipe.end();
-  });
-
-  const close = () => {
-    proc.kill("SIGTERM");
-    vPipe.end();
-    aPipe.end();
-    cleanupSpool();
-  };
-
-  return { video: vInfo, audio: aInfo, close };
-}

services/discord-gateway/src/goLive/Encoders.ts

@@ -1,51 +0,0 @@
-/**
- * Lightweight encoders config — ported from @dank074/discord-video-stream
- * encoders/software.js. Only software (libx264) is needed for GoLive.
- */
-
-export interface EncoderSettings {
-  name: string;
-  options: string[];
-  outFilters?: string[];
-  globalOptions?: string[];
-}
-
-export interface EncoderSet {
-  H264: EncoderSettings;
-  H265: EncoderSettings;
-  VP8: EncoderSettings;
-  VP9: EncoderSettings;
-  AV1: EncoderSettings;
-}
-
-/** Software x264 encoder. Matches @dank074's software() defaults. */
-export function software(
-  opts: {
-    x264?: { preset?: string; tune?: string };
-    x265?: { preset?: string; tune?: string };
-  } = {},
-): () => EncoderSet {
-  const { x264, x265 } = opts;
-  const { preset: x264Preset = "superfast", tune: x264Tune = "film" } =
-    x264 ?? {};
-  const { preset: x265Preset = "superfast", tune: x265Tune } = x265 ?? {};
-  return () => ({
-    H264: {
-      name: "libx264",
-      options: ["-forced-idr 1", `-tune ${x264Tune}`, `-preset ${x264Preset}`],
-    },
-    H265: {
-      name: "libx265",
-      options: [
-        "-forced-idr 1",
-        ...(x265Tune ? [`-tune ${x265Tune}`] : []),
-        `-preset ${x265Preset}`,
-      ],
-    },
-    VP8: { name: "libvpx", options: ["-deadline 20000"] },
-    VP9: { name: "libvpx-vp9", options: ["-deadline 20000"] },
-    AV1: { name: "libsvtav1", options: [] },
-  });
-}
-
-export const Encoders = { software };

services/discord-gateway/src/goLive/GatewayOpCodes.ts

@@ -1,41 +0,0 @@
-/** Discord gateway opcodes used by Streamer — ported from @dank074/discord-video-stream. */
-export enum GatewayOpCodes {
-  DISPATCH = 0,
-  HEARTBEAT = 1,
-  IDENTIFY = 2,
-  PRESENCE_UPDATE = 3,
-  VOICE_STATE_UPDATE = 4,
-  VOICE_SERVER_PING = 5,
-  RESUME = 6,
-  RECONNECT = 7,
-  REQUEST_GUILD_MEMBERS = 8,
-  INVALID_SESSION = 9,
-  HELLO = 10,
-  HEARTBEAT_ACK = 11,
-  CALL_CONNECT = 13,
-  GUILD_SUBSCRIPTIONS = 14,
-  LOBBY_CONNECT = 15,
-  LOBBY_DISCONNECT = 16,
-  LOBBY_VOICE_STATES_UPDATE = 17,
-  STREAM_CREATE = 18,
-  STREAM_DELETE = 19,
-  STREAM_WATCH = 20,
-  STREAM_PING = 21,
-  STREAM_SET_PAUSED = 22,
-  REQUEST_GUILD_APPLICATION_COMMANDS = 24,
-  EMBEDDED_ACTIVITY_LAUNCH = 25,
-  EMBEDDED_ACTIVITY_CLOSE = 26,
-  EMBEDDED_ACTIVITY_UPDATE = 27,
-  REQUEST_FORUM_UNREADS = 28,
-  REMOTE_COMMAND = 29,
-  GET_DELETED_ENTITY_IDS_NOT_MATCHING_HASH = 30,
-  REQUEST_SOUNDBOARD_SOUNDS = 31,
-  SPEED_TEST_CREATE = 32,
-  SPEED_TEST_DELETE = 33,
-  REQUEST_LAST_MESSAGES = 34,
-  SEARCH_RECENT_MEMBERS = 35,
-  REQUEST_CHANNEL_STATUSES = 36,
-  GUILD_SUBSCRIPTIONS_BULK = 37,
-  GUILD_CHANNELS_RESYNC = 38,
-  REQUEST_CHANNEL_MEMBER_COUNT = 39,
-}

services/discord-gateway/src/goLive/SPSVUIRewriter.ts

@@ -1,291 +0,0 @@
-/**
- * H264 SPS VUI rewriter — ported from @dank074/discord-video-stream
- * SPSVUIRewriter.js. Rewrites the SPS so Discord's receiver applies
- * bitstream restrictions (max_num_reorder_frames=0, max_dec_frame_buffering
- * bounded) — required for low-latency GoLive decode.
- */
-
-import {
-  AnnexBBitstreamReader,
-  AnnexBBitstreamWriter,
-} from "./AnnexBBitstreamReaderWriter.js";
-
-export function rewriteSPSVUI(buffer: Uint8Array): Buffer {
-  const reader = new AnnexBBitstreamReader(buffer.subarray(1));
-  const writer = new AnnexBBitstreamWriter();
-  const readBit = (n = 1) => reader.readBits(n);
-  const writeBit = (v: number, n = 1) => writer.writeBits(v, n);
-  const readU = (n: number) => reader.readUnsigned(n);
-  const writeU = (v: number, n: number) => writer.writeUnsigned(v, n);
-  const readUE = () => reader.readUnsignedExpGolomb();
-  const writeUE = (v: number) => writer.writeUnsignedExpGolomb(v);
-  const readSE = () => reader.readSignedExpGolomb();
-  const writeSE = (v: number) => writer.writeSignedExpGolomb(v);
-
-  // Rewrite the NAL header
-  writeU(buffer[0], 8);
-  const profile_idc = readU(8);
-  writeU(profile_idc, 8);
-  const constraint_flags = readU(8);
-  writeU(constraint_flags, 8);
-  const level_idc = readU(8);
-  writeU(level_idc, 8);
-  const seq_parameter_set_id = readUE();
-  writeUE(seq_parameter_set_id);
-
-  // If profile in high profiles, additional fields
-  const highProfiles = new Set([
-    100, 110, 122, 244, 44, 83, 86, 118, 128, 138, 144,
-  ]);
-  if (highProfiles.has(profile_idc)) {
-    const chroma_format_idc = readUE();
-    writeUE(chroma_format_idc);
-    if (chroma_format_idc === 3) {
-      const separate_colour_plane_flag = readBit(1);
-      writeBit(separate_colour_plane_flag, 1);
-    }
-    const bit_depth_luma_minus8 = readUE();
-    writeUE(bit_depth_luma_minus8);
-    const bit_depth_chroma_minus8 = readUE();
-    writeUE(bit_depth_chroma_minus8);
-    const qpprime_y_zero_transform_bypass_flag = readBit(1);
-    writeBit(qpprime_y_zero_transform_bypass_flag, 1);
-    const seq_scaling_matrix_present_flag = readBit(1);
-    writeBit(seq_scaling_matrix_present_flag, 1);
-    if (seq_scaling_matrix_present_flag) {
-      const scalingCount = chroma_format_idc !== 3 ? 8 : 12;
-      for (let i = 0; i < scalingCount; i++) {
-        const seq_scaling_list_present_flag = readBit(1);
-        writeBit(seq_scaling_list_present_flag, 1);
-        if (seq_scaling_list_present_flag) {
-          const size = i < 6 ? 16 : 64;
-          let lastScale = 8;
-          let nextScale = 8;
-          for (let j = 0; j < size; j++) {
-            const delta = readSE();
-            writeSE(delta);
-            nextScale = (lastScale + delta + 256) % 256;
-            if (nextScale !== 0) lastScale = nextScale;
-          }
-        }
-      }
-    }
-  }
-
-  const log2_max_frame_num_minus4 = readUE();
-  writeUE(log2_max_frame_num_minus4);
-  const pic_order_cnt_type = readUE();
-  writeUE(pic_order_cnt_type);
-  if (pic_order_cnt_type === 0) {
-    const log2_max_pic_order_cnt_lsb_minus4 = readUE();
-    writeUE(log2_max_pic_order_cnt_lsb_minus4);
-  } else if (pic_order_cnt_type === 1) {
-    const delta_pic_order_always_zero_flag = readBit(1);
-    writeBit(delta_pic_order_always_zero_flag, 1);
-    const offset_for_non_ref_pic = readSE();
-    writeSE(offset_for_non_ref_pic);
-    const offset_for_top_to_bottom_field = readSE();
-    writeSE(offset_for_top_to_bottom_field);
-    const num_ref_frames_in_pic_order_cnt_cycle = readUE();
-    writeUE(num_ref_frames_in_pic_order_cnt_cycle);
-    for (let i = 0; i < num_ref_frames_in_pic_order_cnt_cycle; i++) {
-      const offset_for_ref_frame = readSE();
-      writeSE(offset_for_ref_frame);
-    }
-  }
-  const max_num_ref_frames = readUE();
-  writeUE(max_num_ref_frames);
-  const gaps_in_frame_num_value_allowed_flag = readBit(1);
-  writeBit(gaps_in_frame_num_value_allowed_flag, 1);
-  const pic_width_in_mbs_minus1 = readUE();
-  writeUE(pic_width_in_mbs_minus1);
-  const pic_height_in_map_units_minus1 = readUE();
-  writeUE(pic_height_in_map_units_minus1);
-  const frame_mbs_only_flag = readBit(1);
-  writeBit(frame_mbs_only_flag, 1);
-  if (frame_mbs_only_flag === 0) {
-    const mb_adaptive_frame_field_flag = readBit(1);
-    writeBit(mb_adaptive_frame_field_flag, 1);
-  }
-  const direct_8x8_inference_flag = readBit(1);
-  writeBit(direct_8x8_inference_flag, 1);
-  const frame_cropping_flag = readBit(1);
-  writeBit(frame_cropping_flag, 1);
-  if (frame_cropping_flag) {
-    const frame_crop_left_offset = readUE();
-    writeUE(frame_crop_left_offset);
-    const frame_crop_right_offset = readUE();
-    writeUE(frame_crop_right_offset);
-    const frame_crop_top_offset = readUE();
-    writeUE(frame_crop_top_offset);
-    const frame_crop_bottom_offset = readUE();
-    writeUE(frame_crop_bottom_offset);
-  }
-
-  // https://webrtc.googlesource.com/src/+/5f2c9278f35e47ff72eb191669d473b7400c9f3e/common_video/h264/sps_vui_rewriter.cc#283
-  function addBitstreamRestriction() {
-    // motion_vectors_over_pic_boundaries_flag: u(1) — Default is 1 when not present.
-    writeBit(1, 1);
-    // max_bytes_per_pic_denom: ue(v) — Default is 2 when not present.
-    writeUE(2);
-    // max_bits_per_mb_denom: ue(v) — Default is 1 when not present.
-    writeUE(1);
-    // log2_max_mv_length_horizontal / vertical — both default to 16.
-    writeUE(16);
-    writeUE(16);
-    // IMPORTANT: max_num_reorder_frames must be 0 for low latency.
-    writeUE(0);
-    writeUE(max_num_ref_frames);
-  }
-
-  const vui_parameters_present_flag = readBit(1);
-  writeBit(1, 1);
-  // If no VUI exists, write one
-  if (!vui_parameters_present_flag) {
-    // aspect_ratio_info_present_flag, overscan_info_present_flag. Both u(1).
-    writeBit(0, 2);
-    // video_signal_type_present_flag, u(1) — write 0, ignore color space.
-    writeBit(0, 1);
-    // chroma_loc_info_present_flag, timing_info_present_flag,
-    // nal_hrd_parameters_present_flag, vcl_hrd_parameters_present_flag,
-    // pic_struct_present_flag — all u(1)
-    writeBit(0, 5);
-    // bitstream_restriction_flag: u(1)
-    writeBit(1, 1);
-    addBitstreamRestriction();
-  } else {
-    // VUI parsing and copying
-    const aspect_ratio_info_present_flag = readBit(1);
-    writeBit(aspect_ratio_info_present_flag, 1);
-    if (aspect_ratio_info_present_flag) {
-      const aspect_ratio_idc = readU(8);
-      writeU(aspect_ratio_idc, 8);
-      if (aspect_ratio_idc === 255) {
-        const sar_width = readU(16);
-        writeU(sar_width, 16);
-        const sar_height = readU(16);
-        writeU(sar_height, 16);
-      }
-    }
-    const overscan_info_present_flag = readBit(1);
-    writeBit(overscan_info_present_flag, 1);
-    if (overscan_info_present_flag) {
-      const overscan_appropriate_flag = readBit(1);
-      writeBit(overscan_appropriate_flag, 1);
-    }
-    // Read the video signal type, but don't copy it
-    const video_signal_type_present_flag = readBit(1);
-    writeBit(0, 1);
-    if (video_signal_type_present_flag) {
-      readBit(3); // _video_format
-      readBit(1); // _video_full_range_flag
-      const colour_description_present_flag = readBit(1);
-      if (colour_description_present_flag) {
-        readU(8); // _colour_primaries
-        readU(8); // _transfer_characteristics
-        readU(8); // _matrix_coeffs
-      }
-    }
-    const chroma_loc_info_present_flag = readBit(1);
-    writeBit(chroma_loc_info_present_flag, 1);
-    if (chroma_loc_info_present_flag) {
-      const chroma_sample_loc_type_top_field = readUE();
-      writeUE(chroma_sample_loc_type_top_field);
-      const chroma_sample_loc_type_bottom_field = readUE();
-      writeUE(chroma_sample_loc_type_bottom_field);
-    }
-    const timing_info_present_flag = readBit(1);
-    writeBit(timing_info_present_flag, 1);
-    if (timing_info_present_flag) {
-      const num_units_in_tick = readU(32);
-      writeU(num_units_in_tick, 32);
-      const time_scale = readU(32);
-      writeU(time_scale, 32);
-      const fixed_frame_rate_flag = readBit(1);
-      writeBit(fixed_frame_rate_flag, 1);
-    }
-    const nal_hrd_parameters_present_flag = readBit(1);
-    writeBit(nal_hrd_parameters_present_flag, 1);
-    if (nal_hrd_parameters_present_flag) {
-      // hrd_parameters()
-      const cpb_cnt_minus1 = readUE();
-      writeUE(cpb_cnt_minus1);
-      const bit_rate_scale = readBit(4);
-      writeBit(bit_rate_scale, 4);
-      const cpb_size_scale = readBit(4);
-      writeBit(cpb_size_scale, 4);
-      for (let i = 0; i <= cpb_cnt_minus1; i++) {
-        const bit_rate_value_minus1 = readUE();
-        writeUE(bit_rate_value_minus1);
-        const cpb_size_value_minus1 = readUE();
-        writeUE(cpb_size_value_minus1);
-        const cbr_flag = readBit(1);
-        writeBit(cbr_flag, 1);
-      }
-      const initial_cpb_removal_delay_length_minus1 = readBit(5);
-      writeBit(initial_cpb_removal_delay_length_minus1, 5);
-      const cpb_removal_delay_length_minus1 = readBit(5);
-      writeBit(cpb_removal_delay_length_minus1, 5);
-      const dpb_output_delay_length_minus1 = readBit(5);
-      writeBit(dpb_output_delay_length_minus1, 5);
-      const time_offset_length = readBit(5);
-      writeBit(time_offset_length, 5);
-    }
-    const vcl_hrd_parameters_present_flag = readBit(1);
-    writeBit(vcl_hrd_parameters_present_flag, 1);
-    if (vcl_hrd_parameters_present_flag) {
-      // hrd_parameters()
-      const cpb_cnt_minus1 = readUE();
-      writeUE(cpb_cnt_minus1);
-      const bit_rate_scale = readBit(4);
-      writeBit(bit_rate_scale, 4);
-      const cpb_size_scale = readBit(4);
-      writeBit(cpb_size_scale, 4);
-      for (let i = 0; i <= cpb_cnt_minus1; i++) {
-        const bit_rate_value_minus1 = readUE();
-        writeUE(bit_rate_value_minus1);
-        const cpb_size_value_minus1 = readUE();
-        writeUE(cpb_size_value_minus1);
-        const cbr_flag = readBit(1);
-        writeBit(cbr_flag, 1);
-      }
-      const initial_cpb_removal_delay_length_minus1 = readBit(5);
-      writeBit(initial_cpb_removal_delay_length_minus1, 5);
-      const cpb_removal_delay_length_minus1 = readBit(5);
-      writeBit(cpb_removal_delay_length_minus1, 5);
-      const dpb_output_delay_length_minus1 = readBit(5);
-      writeBit(dpb_output_delay_length_minus1, 5);
-      const time_offset_length = readBit(5);
-      writeBit(time_offset_length, 5);
-    }
-    if (nal_hrd_parameters_present_flag || vcl_hrd_parameters_present_flag) {
-      const low_delay_hrd_flag = readBit(1);
-      writeBit(low_delay_hrd_flag, 1);
-    }
-    const pic_struct_present_flag = readBit(1);
-    writeBit(pic_struct_present_flag, 1);
-    const bitstream_restriction_flag = readBit(1);
-    writeBit(1, 1);
-    if (!bitstream_restriction_flag) {
-      addBitstreamRestriction();
-    } else {
-      const motion_vectors_over_pic_boundaries_flag = readBit(1);
-      writeBit(motion_vectors_over_pic_boundaries_flag, 1);
-      const max_bytes_per_pic_denom = readUE();
-      writeUE(max_bytes_per_pic_denom);
-      const max_bits_per_mb_denom = readUE();
-      writeUE(max_bits_per_mb_denom);
-      const log2_max_mv_length_horizontal = readUE();
-      writeUE(log2_max_mv_length_horizontal);
-      const log2_max_mv_length_vertical = readUE();
-      writeUE(log2_max_mv_length_vertical);
-      readUE(); // _num_reorder_frames
-      writeUE(0);
-      readUE(); // _max_dec_frame_buffering
-      writeUE(max_num_ref_frames);
-    }
-  }
-  writeBit(1, 1); // rbsp_stop_one_bit
-  writer.flush();
-  return writer.toBuffer();
-}

services/discord-gateway/src/goLive/StreamConnection.ts

@@ -1,45 +0,0 @@
-/**
- * StreamConnection — GoLive stream connection (screen share).
- * Ported from @dank074/discord-video-stream StreamConnection.js.
- */
-
-import { BaseMediaConnection } from "./BaseMediaConnection.js";
-import { VoiceOpCodes } from "./VoiceOpCodes.js";
-
-export class StreamConnection extends BaseMediaConnection {
-  _streamKey: string | null = null;
-  _serverId: string | null = null;
-
-  setSpeaking(speaking: boolean): void {
-    if (!this.webRtcParams) throw new Error("WebRTC connection not ready");
-    this.sendOpcode(VoiceOpCodes.SPEAKING, {
-      delay: 0,
-      speaking: speaking ? 2 : 0,
-      ssrc: this.webRtcParams.audioSsrc,
-    });
-  }
-
-  get daveChannelId(): string {
-    if (this._serverId === null) {
-      throw new Error("Server ID not set (this shouldn't happen)");
-    }
-    const channelId = BigInt(this._serverId) - 1n;
-    return channelId.toString();
-  }
-
-  get serverId(): string | null {
-    return this._serverId;
-  }
-
-  set serverId(id: string | null) {
-    this._serverId = id;
-  }
-
-  get streamKey(): string | null {
-    return this._streamKey;
-  }
-
-  set streamKey(value: string | null) {
-    this._streamKey = value;
-  }
-}

services/discord-gateway/src/goLive/Streamer.ts

@@ -1,300 +0,0 @@
-/**
- * Streamer — gateway-level GoLive controller. Ported from
- * @dank074/discord-video-stream Streamer.js.
- *
- * Drives the Discord gateway (VOICE_STATE_UPDATE, STREAM_CREATE, ...) and
- * hands back a VoiceConnection / StreamConnection once the media server
- * session is ready.
- */
-
-import { EventEmitter } from "node:events";
-import { GatewayOpCodes } from "./GatewayOpCodes.js";
-import type { NativePeerConnection } from "./native.js";
-import { StreamConnection } from "./StreamConnection.js";
-import { generateStreamKey, parseStreamKey } from "./utils.js";
-import { VoiceConnection } from "./VoiceConnection.js";
-import type { WebRtcConnWrapper } from "./WebRtcWrapper.js";
-
-/** Minimal surface of a discord.js-selfbot-v13 client used by Streamer. */
-export interface StreamerClientLike {
-  user: { id: string; username?: string } | null;
-  token: string | null;
-  on(
-    event: "raw",
-    listener: (packet: { t: string; d: unknown }) => void,
-  ): unknown;
-  ws: {
-    broadcast(data: { op: number; d: unknown }): void;
-  };
-  guilds?: {
-    // biome-ignore lint/suspicious/noExplicitAny: discord.js-selfbot client shape is dynamic
-    fetch(id: string): Promise<any>;
-  };
-}
-
-/** Minimal channel shape accepted by joinVoiceChannel. */
-export interface VoiceChannelLike {
-  id: string;
-  type: string;
-  guildId?: string | null;
-}
-
-export class Streamer {
-  _voiceConnection: VoiceConnection | null = null;
-  _client: StreamerClientLike;
-  _gatewayEmitter = new EventEmitter();
-
-  constructor(client: StreamerClientLike) {
-    this._client = client;
-    // listen for gateway dispatch events
-    this.client.on("raw", (packet) => {
-      const t = packet.t as string;
-      if (
-        t === "STREAM_CREATE" ||
-        t === "STREAM_SERVER_UPDATE" ||
-        t === "VOICE_STATE_UPDATE" ||
-        t === "VOICE_SERVER_UPDATE"
-      ) {
-        console.log(
-          `[goLive:Streamer] raw dispatch ${t}`,
-          JSON.stringify(packet.d).slice(0, 220),
-        );
-      }
-      this._gatewayEmitter.emit(t, packet.d);
-    });
-  }
-
-  get client(): StreamerClientLike {
-    return this._client;
-  }
-
-  get opts(): Record<string, unknown> {
-    return {};
-  }
-
-  get voiceConnection(): VoiceConnection | null {
-    return this._voiceConnection;
-  }
-
-  sendOpcode(code: number, data: unknown): void {
-    this.client.ws.broadcast({ op: code, d: data });
-  }
-
-  joinVoiceChannel(channel: VoiceChannelLike): Promise<WebRtcConnWrapper> {
-    let guildId: string | null = null;
-    if (
-      channel.type === "GUILD_STAGE_VOICE" ||
-      channel.type === "GUILD_VOICE"
-    ) {
-      guildId = channel.guildId ?? null;
-    }
-    return this.joinVoice(guildId, channel.id);
-  }
-
-  /**
-   * Joins a voice channel and resolves with the WebRtcConnWrapper when the
-   * media session is ready.
-   */
-  joinVoice(
-    guild_id: string | null,
-    channel_id: string,
-  ): Promise<WebRtcConnWrapper> {
-    return new Promise((resolve, reject) => {
-      if (!this.client.user) {
-        reject(new Error("Client not logged in"));
-        return;
-      }
-      const user_id = this.client.user.id;
-      const voiceConn = new VoiceConnection(
-        this,
-        guild_id,
-        user_id,
-        channel_id,
-        (conn) => {
-          resolve(conn);
-        },
-      );
-      this._voiceConnection = voiceConn;
-      this._gatewayEmitter.on(
-        "VOICE_STATE_UPDATE",
-        (d: { user_id: string; session_id: string }) => {
-          if (user_id !== d.user_id) return;
-          voiceConn.setSession(d.session_id);
-        },
-      );
-      this._gatewayEmitter.on(
-        "VOICE_SERVER_UPDATE",
-        (d: {
-          guild_id: string | null;
-          channel_id?: string;
-          endpoint: string;
-          token: string;
-        }) => {
-          if (guild_id !== d.guild_id) return;
-          // channel_id is not set for guild voice calls
-          if (d.channel_id && channel_id !== d.channel_id) return;
-          voiceConn.setTokens(d.endpoint, d.token);
-        },
-      );
-      this.signalVideo(false);
-    });
-  }
-
-  /** Create a GoLive stream (screen share) on top of the voice connection. */
-  createStream(): Promise<WebRtcConnWrapper> {
-    return new Promise((resolve, reject) => {
-      if (!this.client.user) {
-        reject(new Error("Client not logged in"));
-        return;
-      }
-      if (!this.voiceConnection) {
-        reject(
-          new Error("cannot start stream without first joining voice channel"),
-        );
-        return;
-      }
-      this.signalStream();
-      const streamTimeout = setTimeout(() => {
-        reject(
-          new Error(
-            "Timed out waiting for STREAM_CREATE/STREAM_SERVER_UPDATE from Discord (stream handshake) — voice media session may not be active",
-          ),
-        );
-      }, 12_000);
-      const {
-        guildId: clientGuildId,
-        channelId: clientChannelId,
-        session_id,
-      } = this.voiceConnection;
-      const clientUserId = this.client.user.id;
-      if (!session_id) throw new Error("Session doesn't exist yet");
-      const streamConn = new StreamConnection(
-        this,
-        clientGuildId,
-        clientUserId,
-        clientChannelId,
-        (conn) => {
-          clearTimeout(streamTimeout);
-          resolve(conn);
-        },
-      );
-      this.voiceConnection.streamConnection = streamConn;
-      this._gatewayEmitter.on(
-        "STREAM_CREATE",
-        (d: { stream_key: string; rtc_server_id: string }) => {
-          const { channelId, guildId, userId } = parseStreamKey(d.stream_key);
-          if (
-            clientGuildId !== guildId ||
-            clientChannelId !== channelId ||
-            clientUserId !== userId
-          ) {
-            return;
-          }
-          streamConn.serverId = d.rtc_server_id;
-          streamConn.streamKey = d.stream_key;
-          streamConn.setSession(session_id);
-        },
-      );
-      this._gatewayEmitter.on(
-        "STREAM_SERVER_UPDATE",
-        (d: { stream_key: string; endpoint: string; token: string }) => {
-          const { channelId, guildId, userId } = parseStreamKey(d.stream_key);
-          if (
-            clientGuildId !== guildId ||
-            clientChannelId !== channelId ||
-            clientUserId !== userId
-          ) {
-            return;
-          }
-          streamConn.setTokens(d.endpoint, d.token);
-        },
-      );
-    });
-  }
-
-  async setStreamPreview(image: Buffer): Promise<void> {
-    if (!this.client.token) throw new Error("Please login :)");
-    if (!this.voiceConnection?.streamConnection?.guildId) return;
-    const data = `data:image/jpeg;base64,${image.toString("base64")}`;
-    const { guildId } = this.voiceConnection.streamConnection;
-    if (!this.client.guilds) return;
-    const server = await this.client.guilds.fetch(guildId);
-    // biome-ignore lint/suspicious/noExplicitAny: discord.js-selfbot dynamic
-    (server as any).members.me?.voice?.postPreview(data);
-  }
-
-  stopStream(): void {
-    const stream = this.voiceConnection?.streamConnection;
-    if (!stream) return;
-    stream.stop();
-    this.signalStopStream();
-    this.voiceConnection.streamConnection = null;
-    this._gatewayEmitter.removeAllListeners("STREAM_CREATE");
-    this._gatewayEmitter.removeAllListeners("STREAM_SERVER_UPDATE");
-  }
-
-  leaveVoice(): void {
-    this.voiceConnection?.stop();
-    this.signalLeaveVoice();
-    this._voiceConnection = null;
-    this._gatewayEmitter.removeAllListeners("VOICE_STATE_UPDATE");
-    this._gatewayEmitter.removeAllListeners("VOICE_SERVER_UPDATE");
-  }
-
-  signalVideo(video_enabled: boolean): void {
-    if (!this.voiceConnection) return;
-    const { guildId: guild_id, channelId: channel_id } = this.voiceConnection;
-    this.sendOpcode(GatewayOpCodes.VOICE_STATE_UPDATE, {
-      guild_id: guild_id,
-      channel_id,
-      self_mute: false,
-      self_deaf: true,
-      self_video: video_enabled,
-    });
-  }
-
-  signalStream(): void {
-    if (!this.voiceConnection) return;
-    const {
-      type,
-      guildId: guild_id,
-      channelId: channel_id,
-      botId: user_id,
-    } = this.voiceConnection;
-    this.sendOpcode(GatewayOpCodes.STREAM_CREATE, {
-      type,
-      guild_id,
-      channel_id,
-      preferred_region: null,
-    });
-    this.sendOpcode(GatewayOpCodes.STREAM_SET_PAUSED, {
-      stream_key: generateStreamKey(type, guild_id, channel_id, user_id),
-      paused: false,
-    });
-  }
-
-  signalStopStream(): void {
-    if (!this.voiceConnection) return;
-    const {
-      type,
-      guildId: guild_id,
-      channelId: channel_id,
-      botId: user_id,
-    } = this.voiceConnection;
-    this.sendOpcode(GatewayOpCodes.STREAM_DELETE, {
-      stream_key: generateStreamKey(type, guild_id, channel_id, user_id),
-    });
-  }
-
-  signalLeaveVoice(): void {
-    this.sendOpcode(GatewayOpCodes.VOICE_STATE_UPDATE, {
-      guild_id: null,
-      channel_id: null,
-      self_mute: true,
-      self_deaf: false,
-      self_video: false,
-    });
-  }
-}
-
-export type { NativePeerConnection };

services/discord-gateway/src/goLive/VideoStream.ts

@@ -1,20 +0,0 @@
-/**
- * VideoStream — feeds encoded H264 frames into the WebRTC connection.
- * Ported from @dank074/discord-video-stream VideoStream.js.
- */
-
-import { BaseMediaStream } from "./BaseMediaStream.js";
-import type { WebRtcConnWrapper } from "./WebRtcWrapper.js";
-
-export class VideoStream extends BaseMediaStream {
-  _conn: WebRtcConnWrapper;
-
-  constructor(conn: WebRtcConnWrapper, noSleep = false) {
-    super("video", noSleep);
-    this._conn = conn;
-  }
-
-  async _sendFrame(frame: Buffer, frametime: number): Promise<void> {
-    this._conn.sendVideoFrame(frame, frametime);
-  }
-}

services/discord-gateway/src/goLive/VoiceConnection.ts

@@ -1,25 +0,0 @@
-/**
- * VoiceConnection — guild/DM voice channel GoLive connection.
- * Ported from @dank074/discord-video-stream VoiceConnection.js.
- */
-
-import { BaseMediaConnection } from "./BaseMediaConnection.js";
-import type { StreamConnection } from "./StreamConnection.js";
-
-export class VoiceConnection extends BaseMediaConnection {
-  streamConnection: StreamConnection | null = null;
-
-  get daveChannelId(): string {
-    return this.channelId;
-  }
-
-  get serverId(): string | null {
-    // for guild vc it is the guild id, for dm voice it is the channel id
-    return this.guildId ?? this.channelId;
-  }
-
-  stop(): void {
-    super.stop();
-    this.streamConnection?.stop();
-  }
-}

services/discord-gateway/src/goLive/VoiceOpCodes.ts

@@ -1,38 +0,0 @@
-/** Discord voice WebSocket opcodes — ported from @dank074/discord-video-stream. */
-export enum VoiceOpCodes {
-  IDENTIFY = 0,
-  SELECT_PROTOCOL = 1,
-  READY = 2,
-  HEARTBEAT = 3,
-  SELECT_PROTOCOL_ACK = 4,
-  SPEAKING = 5,
-  HEARTBEAT_ACK = 6,
-  RESUME = 7,
-  HELLO = 8,
-  RESUMED = 9,
-  CLIENTS_CONNECT = 11,
-  VIDEO = 12,
-  CLIENT_DISCONNECT = 13,
-  SESSION_UPDATE = 14,
-  MEDIA_SINK_WANTS = 15,
-  VOICE_BACKEND_VERSION = 16,
-  CHANNEL_OPTIONS_UPDATE = 17,
-  FLAGS = 18,
-  SPEED_TEST = 19,
-  PLATFORM = 20,
-  DAVE_PREPARE_TRANSITION = 21,
-  DAVE_EXECUTE_TRANSITION = 22,
-  DAVE_TRANSITION_READY = 23,
-  DAVE_PREPARE_EPOCH = 24,
-  MLS_INVALID_COMMIT_WELCOME = 31,
-}
-
-/** Binary voice WebSocket opcodes (DAVE / MLS). */
-export enum VoiceOpCodesBinary {
-  MLS_EXTERNAL_SENDER = 25,
-  MLS_KEY_PACKAGE = 26,
-  MLS_PROPOSALS = 27,
-  MLS_COMMIT_WELCOME = 28,
-  MLS_ANNOUNCE_COMMIT_TRANSITION = 29,
-  MLS_WELCOME = 30,
-}

services/discord-gateway/src/goLive/WebRtcWrapper.ts

@@ -1,205 +0,0 @@
-/**
- * WebRTC connection wrapper for GoLive — ported from
- * @dank074/discord-video-stream WebRtcWrapper.js, with the media stack
- * (packetizers, RTCP SR/NACK, pacing) provided by the libdatachannel-min
- * binding instead of node-datachannel's JS-exposed media classes.
- */
-
-import {
-  H264Helpers,
-  H264NalUnitTypes,
-  splitNalu,
-  startCode3,
-} from "./AnnexBHelper.js";
-import { CodecPayloadType } from "./CodecPayloadType.js";
-import type { NativePeerConnection, NativeTrack } from "./native.js";
-import { loadNative } from "./native.js";
-import { rewriteSPSVUI } from "./SPSVUIRewriter.js";
-import { normalizeVideoCodec } from "./utils.js";
-
-export type WebRtcVideoCodec = "H264" | "H265" | "VP8" | "VP9" | "AV1";
-
-export interface WebRtcParams {
-  address: string;
-  port: number;
-  audioSsrc: number;
-  videoSsrc: number;
-  rtxSsrc: number;
-  supportedEncryptionModes: string[];
-}
-
-/** Minimal surface of the media connection that WebRtcWrapper drives. */
-export interface VideoAttribute {
-  fps: number;
-  width: number;
-  height: number;
-}
-
-export interface MediaConnectionLike {
-  daveReady: boolean;
-  daveSession: {
-    encryptOpus(frame: Buffer): Buffer;
-    encrypt(mediaType: number, codec: number, frame: Buffer): Buffer;
-  } | null;
-  webRtcParams: WebRtcParams | null;
-  setSpeaking(speaking: boolean): void;
-  setVideoAttributes(enabled: boolean, attr?: VideoAttribute): void;
-}
-
-/** Media types used by DAVE encryption (from @dank074). */
-export enum DaveMediaType {
-  AUDIO = 0,
-  VIDEO = 1,
-}
-
-/** DAVE codec ids (from @dank074). */
-export enum DaveCodec {
-  UNKNOWN = 0,
-  VP8 = 2,
-  VP9 = 3,
-  H264 = 4,
-  H265 = 5,
-  AV1 = 6,
-}
-
-export class WebRtcConnWrapper {
-  private _mediaConn: MediaConnectionLike;
-  private _webRtcConn: NativePeerConnection | null = null;
-  private _audioTrack: NativeTrack | null = null;
-  private _videoTrack: NativeTrack | null = null;
-  private _videoCodec: WebRtcVideoCodec | null = null;
-  /** Assigned by BaseMediaConnection to send the gathered SDP to Discord. */
-  onLocalDescription: ((sdp: string) => void) | null = null;
-
-  constructor(mediaConn: MediaConnectionLike) {
-    this._mediaConn = mediaConn;
-  }
-
-  initWebRtc(): NativePeerConnection {
-    const native = loadNative();
-    this._webRtcConn = new native.PeerConnection({
-      iceServers: ["stun:stun.l.google.com:19302"],
-    });
-    // Track mids must match @dank074: "0" audio, "1" video.
-    this._audioTrack = this._webRtcConn.addTrack("0", "audio");
-    this._videoTrack = this._webRtcConn.addTrack("1", "video");
-    return this._webRtcConn;
-  }
-
-  close(): void {
-    this._webRtcConn?.close();
-    this._webRtcConn = null;
-  }
-
-  get webRtcConn(): NativePeerConnection | null {
-    return this._webRtcConn;
-  }
-
-  get ready(): boolean {
-    return this._webRtcConn?.state() === "connected";
-  }
-
-  get mediaConnection(): MediaConnectionLike {
-    return this._mediaConn;
-  }
-
-  sendAudioFrame(frame: Buffer, frametime: number): void {
-    if (!this.ready || !this._audioTrack) return;
-    const clockRate = CodecPayloadType.opus.clockRate;
-    if (this.mediaConnection.daveReady && this.mediaConnection.daveSession) {
-      frame = this.mediaConnection.daveSession.encryptOpus(frame);
-    }
-    this._audioTrack.sendFrame(frame);
-    this._audioTrack.addTimestamp(Math.round((frametime * clockRate) / 1000));
-  }
-
-  sendVideoFrame(frame: Buffer, frametime: number): void {
-    if (!this.ready || !this._videoTrack) return;
-    const clockRate = CodecPayloadType[this._videoCodec ?? "H264"].clockRate;
-    if (this._videoCodec === "H264") {
-      let spsRewritten = false;
-      const nalus = splitNalu(frame).map((el) => {
-        if (H264Helpers.getUnitType(el) === H264NalUnitTypes.SPS) {
-          spsRewritten = true;
-          return rewriteSPSVUI(el);
-        }
-        return el;
-      });
-      if (spsRewritten)
-        frame = Buffer.concat(nalus.flatMap((el) => [startCode3, el]));
-    }
-    if (this.mediaConnection.daveReady && this.mediaConnection.daveSession) {
-      let daveCodec = DaveCodec.UNKNOWN;
-      switch (this._videoCodec) {
-        case "H264":
-          daveCodec = DaveCodec.H264;
-          break;
-        case "H265":
-          daveCodec = DaveCodec.H265;
-          break;
-        case "VP8":
-          daveCodec = DaveCodec.VP8;
-          break;
-        case "VP9":
-          daveCodec = DaveCodec.VP9;
-          break;
-        case "AV1":
-          daveCodec = DaveCodec.AV1;
-          break;
-        default:
-          break;
-      }
-      frame = this.mediaConnection.daveSession.encrypt(
-        DaveMediaType.VIDEO,
-        daveCodec,
-        frame,
-      );
-    }
-    this._videoTrack.sendFrame(frame);
-    this._videoTrack.addTimestamp(Math.round((frametime * clockRate) / 1000));
-  }
-
-  setPacketizer(videoCodec: string): void {
-    if (!this.mediaConnection.webRtcParams) {
-      throw new Error("WebRTC connection not ready");
-    }
-    const { audioSsrc, videoSsrc } = this.mediaConnection.webRtcParams;
-    this._videoCodec = normalizeVideoCodec(videoCodec);
-    // Audio packetizer: opus 120 @ 48kHz, playout delay ext id 5 (like @dank074)
-    this._audioTrack?.setPacketizer(
-      "audio",
-      audioSsrc,
-      CodecPayloadType.opus.payload_type,
-      CodecPayloadType.opus.clockRate,
-      5,
-      0,
-      1,
-    );
-    // Video packetizer: H264/H265/AV1 with their payload types
-    const codecEntry = CodecPayloadType[this._videoCodec];
-    if (!codecEntry) {
-      throw new Error(`Packetizer not implemented for ${this._videoCodec}`);
-    }
-    const nativeKind =
-      this._videoCodec === "H264"
-        ? "h264"
-        : this._videoCodec === "H265"
-          ? "h265"
-          : this._videoCodec === "AV1"
-            ? "av1"
-            : (() => {
-                throw new Error(
-                  `Packetizer not implemented for ${this._videoCodec}`,
-                );
-              })();
-    this._videoTrack?.setPacketizer(
-      nativeKind,
-      videoSsrc,
-      codecEntry.payload_type,
-      codecEntry.clockRate,
-      5,
-      0,
-      10,
-    );
-  }
-}

services/discord-gateway/src/goLive/index.ts

@@ -1,19 +0,0 @@
-/**
- * goLive public API — re-exports the ported @dank074 modules.
- * Drop-in replacement for `@dank074/discord-video-stream` in
- * screenShareController.ts.
- */
-
-export { AudioStream } from "./AudioStream.js";
-export { BaseMediaConnection } from "./BaseMediaConnection.js";
-export { BaseMediaStream } from "./BaseMediaStream.js";
-export { CodecPayloadType } from "./CodecPayloadType.js";
-export { demux } from "./Demuxer.js";
-export { Encoders } from "./Encoders.js";
-export { playStream, prepareStream } from "./prepareStream.js";
-export { StreamConnection } from "./StreamConnection.js";
-export { Streamer } from "./Streamer.js";
-export { normalizeVideoCodec } from "./utils.js";
-export { VideoStream } from "./VideoStream.js";
-export { VoiceConnection } from "./VoiceConnection.js";
-export { WebRtcConnWrapper } from "./WebRtcWrapper.js";

services/discord-gateway/src/goLive/native.ts

@@ -1,116 +0,0 @@
-/**
- * Loader + typings for the minimal libdatachannel N-API binding
- * (native/libdatachannel-min). The binding exposes ONLY what GoLive needs:
- * PeerConnection, DataChannel, Track (raw RTP + media packetizer chain).
- *
- * The .node file is built by node-gyp against libdatachannel 0.24.0 (built
- * from source — nixpkgs 0.24.1 is glibc-incompatible with this host). It is
- * NOT shipped via npm; the Nix flake builds it as part of the gateway.
- */
-
-export interface NativeTrack {
-  /** Send a RAW RTP/RTCP packet (no media handler installed). */
-  send(buffer: Uint8Array): void;
-  /** Send an ENCODED frame; the packetizer chain turns it into RTP. */
-  sendFrame(buffer: Uint8Array): void;
-  /** Advance the packetizer RTP timestamp by delta (clock-rate units). */
-  addTimestamp(delta: number): void;
-  /** Install the media-handler chain (packetizer → RTCP SR → NACK → pacing). */
-  setPacketizer(
-    kind: "audio" | "h264" | "h265" | "av1",
-    ssrc: number,
-    payloadType: number,
-    clockRate: number,
-    playoutDelayId: number,
-    playoutDelayMin: number,
-    playoutDelayMax: number,
-  ): void;
-  isOpen(): boolean;
-  close(): void;
-}
-
-export interface NativePeerConnection {
-  /** mid must be "0" (audio) or "1" (video) — matches @dank074's track defs. */
-  addTrack(mid: string, kind: "audio" | "video"): NativeTrack;
-  /** Resolves with the full SDP (incl. candidates) after gathering completes. */
-  createOffer(): Promise<string>;
-  /** Resolves with the auto-generated answer SDP. */
-  createAnswer(offerSdp: string): Promise<string>;
-  setRemoteDescription(sdp: string, type: "offer" | "answer"): void;
-  state(): string;
-  close(): void;
-  onStateChange(cb: (state: string) => void): void;
-}
-
-export interface NativeBinding {
-  PeerConnection: new (config: {
-    iceServers: string[];
-  }) => NativePeerConnection;
-  DataChannel: unknown;
-  Track: unknown;
-}
-
-let cached: NativeBinding | null = null;
-
-/** Load the native binding. Throws only if the .node is truly missing —
- *  callers (screen share) guard with `isNativeAvailable()`. */
-export function loadNative(): NativeBinding {
-  if (cached) return cached;
-  // Resolve relative to this file: src/goLive/ → native/libdatachannel-min/
-  const candidates = [
-    new URL(
-      "../../native/libdatachannel-min/build/Release/datachannel_min.node",
-      import.meta.url,
-    ),
-    new URL(
-      "../../../native/libdatachannel-min/build/Release/datachannel_min.node",
-      import.meta.url,
-    ),
-  ];
-  let lastErr: unknown;
-  for (const url of candidates) {
-    try {
-      // @ts-expect-error — .node modules are not typed; dynamic require via file URL
-      const mod = process.dlopen ? null : null;
-      void mod;
-      const nativePath = url.pathname;
-      // eslint-disable-next-line @typescript-eslint/no-require-imports
-      const req = createRequire(import.meta.url);
-      const binding = req(nativePath) as NativeBinding;
-      if (typeof binding.PeerConnection === "function") {
-        cached = binding;
-        return binding;
-      }
-    } catch (e) {
-      lastErr = e;
-    }
-  }
-  // Fallback: plain relative require (tsx / jest environments)
-  try {
-    const req = createRequire(import.meta.url);
-    const binding = req(
-      "../../native/libdatachannel-min/build/Release/datachannel_min.node",
-    ) as NativeBinding;
-    if (typeof binding.PeerConnection === "function") {
-      cached = binding;
-      return binding;
-    }
-  } catch (e) {
-    lastErr = e;
-  }
-  throw new Error(
-    `libdatachannel-min native binding not built (${String(lastErr)}). Run: cd native/libdatachannel-min && npx node-gyp rebuild`,
-  );
-}
-
-import { createRequire } from "node:module";
-
-/** True when the native binding is built — screen share stays disabled otherwise. */
-export function isNativeAvailable(): boolean {
-  try {
-    loadNative();
-    return true;
-  } catch {
-    return false;
-  }
-}

services/discord-gateway/src/goLive/prepareStream.ts

@@ -1,325 +0,0 @@
-/**
- * prepareStream & playStream — ported from @dank074/discord-video-stream
- * newApi.js (Encoders/prepareStream/playStream), but uses `child_process.spawn`
- * + ffmpeg CLI args directly instead of fluent-ffmpeg + node-av.
- *
- * Replaces the @dank074 video pipeline entirely:
- *   input (URL or Readable) → ffmpeg spawn → H264 AnnexB frames
- *   → Demuxer stream → VideoStream/AudioStream → WebRtcConnWrapper
- */
-
-import { type ChildProcess, spawn } from "node:child_process";
-import { existsSync, readdirSync } from "node:fs";
-import { join } from "node:path";
-import { PassThrough, type Readable } from "node:stream";
-import { demux } from "./Demuxer.js";
-import { type EncoderSettings, Encoders } from "./Encoders.js";
-import { VideoStream } from "./VideoStream.js";
-import type { WebRtcConnWrapper } from "./WebRtcWrapper.js";
-
-export interface PrepareStreamResult {
-  command: ChildProcess;
-  output: PassThrough;
-  encoder: () => Record<string, EncoderSettings>;
-  options: Record<string, unknown>;
-  videoCodec: string;
-  width: number;
-  height: number;
-  frameRate?: number;
-  includeAudio: boolean;
-}
-
-function isFiniteNonZero(n: unknown): n is number {
-  return typeof n === "number" && !!n && Number.isFinite(n);
-}
-
-const DEFAULT_HEADERS = {
-  "User-Agent":
-    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/107.0.0.0 Safari/537.36",
-  Connection: "keep-alive",
-};
-
-/** Resolve ffmpeg binary (env override → PATH → Nix store ffmpeg-headless). */
-function resolveFfmpeg(): string {
-  if (process.env.FFMPEG_PATH && existsSync(process.env.FFMPEG_PATH)) {
-    return process.env.FFMPEG_PATH;
-  }
-  const store = "/nix/store";
-  if (existsSync(store)) {
-    const entries = readdirSync(store);
-    for (const entry of entries) {
-      if (!entry.includes("ffmpeg-headless-")) continue;
-      const candidate = join(store, entry, "bin", "ffmpeg");
-      if (existsSync(candidate)) return candidate;
-    }
-  }
-  return "ffmpeg";
-}
-
-const FFMPEG_BIN = resolveFfmpeg();
-
-/**
- * prepareStream — build an ffmpeg command (as spawn args + PassThrough output)
- * that transcodes the input into a pipe we can demux. Mirrors @dank074's
- * prepareStream but produces a raw spawn instead of a fluent-ffmpeg command.
- */
-export function prepareStream(
-  input: string | Readable,
-  options: Record<string, unknown> = {},
-): PrepareStreamResult {
-  const mergedOptions = {
-    noTranscoding: false,
-    width: isFiniteNonZero(options.width)
-      ? Math.round(options.width as number)
-      : -2,
-    height: isFiniteNonZero(options.height)
-      ? Math.round(options.height as number)
-      : -2,
-    frameRate:
-      isFiniteNonZero(options.frameRate) && (options.frameRate as number) > 0
-        ? options.frameRate
-        : undefined,
-    videoCodec: (options.videoCodec as string) ?? "H264",
-    bitrateVideo:
-      isFiniteNonZero(options.bitrateVideo) &&
-      (options.bitrateVideo as number) > 0
-        ? Math.round(options.bitrateVideo as number)
-        : 5000,
-    bitrateVideoMax:
-      isFiniteNonZero(options.bitrateVideoMax) &&
-      (options.bitrateVideoMax as number) > 0
-        ? Math.round(options.bitrateVideoMax as number)
-        : 7000,
-    bitrateAudio:
-      isFiniteNonZero(options.bitrateAudio) &&
-      (options.bitrateAudio as number) > 0
-        ? Math.round(options.bitrateAudio as number)
-        : 128,
-    includeAudio: options.includeAudio ?? true,
-    encoder:
-      (options.encoder as () => Record<string, EncoderSettings>) ??
-      Encoders.software(),
-    customHeaders: {
-      ...DEFAULT_HEADERS,
-      ...(options.customHeaders as Record<string, string> | undefined),
-    },
-    customInputOptions: (options.customInputOptions as string[]) ?? [],
-    customFfmpegFlags: (options.customFfmpegFlags as string[]) ?? [],
-    minimizeLatency: options.minimizeLatency ?? false,
-  };
-
-  const output = new PassThrough();
-
-  const args: string[] = [
-    "-hide_banner",
-    "-loglevel",
-    "error",
-    ...(typeof input === "string" ? ["-i", input] : ["-i", "pipe:0"]),
-    ...mergedOptions.customInputOptions,
-  ];
-
-  if (mergedOptions.minimizeLatency) {
-    args.push("-fflags", "nobuffer", "-analyzeduration", "0");
-  }
-
-  if (typeof input === "string" && input.startsWith("http")) {
-    const headerStr = Object.entries(mergedOptions.customHeaders)
-      .map(([k, v]) => `${k}: ${v}`)
-      .join("\r\n");
-    args.push(
-      "-headers",
-      headerStr,
-      "-reconnect",
-      "1",
-      "-reconnect_at_eof",
-      "1",
-      "-reconnect_streamed",
-      "1",
-      "-reconnect_delay_max",
-      "4294",
-    );
-  }
-
-  // Video
-  args.push("-map", "0:v:0");
-  if (mergedOptions.noTranscoding) {
-    args.push("-c:v", "copy");
-  } else {
-    args.push(`-vf`, `scale=${mergedOptions.width}:${mergedOptions.height}`);
-    if (mergedOptions.frameRate)
-      args.push("-r", String(mergedOptions.frameRate));
-    const enc = mergedOptions.encoder()[mergedOptions.videoCodec];
-    if (!enc)
-      throw new Error(
-        `Encoder settings not specified for ${mergedOptions.videoCodec}`,
-      );
-    // Encoder options are declared as single strings like "-forced-idr 1";
-    // spawn needs each flag and value as separate argv entries.
-    const encOptions = enc.options.flatMap((opt) =>
-      opt.split(/\s+/).filter(Boolean),
-    );
-    args.push(
-      "-b:v",
-      `${mergedOptions.bitrateVideo}k`,
-      "-maxrate:v",
-      `${mergedOptions.bitrateVideoMax}k`,
-      "-bufsize:v",
-      `${Math.round(mergedOptions.bitrateVideo / 2)}k`,
-      "-bf",
-      "0",
-      "-pix_fmt",
-      "yuv420p",
-      "-force_key_frames",
-      "expr:gte(t,n_forced*1)",
-      "-c:v",
-      enc.name,
-      ...encOptions,
-      ...(enc.globalOptions ?? []).flatMap((opt) =>
-        opt.split(/\s+/).filter(Boolean),
-      ),
-    );
-  }
-
-  // Audio
-  if (mergedOptions.includeAudio) {
-    args.push("-map", "0:a:0?");
-    args.push(
-      "-c:a",
-      "libopus",
-      "-b:a",
-      `${mergedOptions.bitrateAudio}k`,
-      "-ar",
-      "48000",
-      "-ac",
-      "2",
-    );
-  } else {
-    args.push("-an");
-  }
-
-  args.push(...mergedOptions.customFfmpegFlags);
-  args.push("-f", "h264", "pipe:1");
-
-  const isUrl = typeof input === "string";
-  const proc: ChildProcess = isUrl
-    ? spawn(FFMPEG_BIN, args, { stdio: ["ignore", "pipe", "pipe"] })
-    : spawn(FFMPEG_BIN, args, { stdio: ["pipe", "pipe", "pipe"] });
-
-  if (proc.stdin && !isUrl) {
-    input.on("data", (chunk: Buffer) => proc.stdin?.write(chunk));
-    input.on("end", () => proc.stdin?.end());
-    input.on("error", () => proc.stdin?.destroy());
-  }
-
-  proc.stdout?.pipe(output);
-  proc.stderr?.on("data", () => {
-    /* swallow ffmpeg stderr */
-  });
-  proc.on("error", (err) => {
-    // spawn failed (e.g. ffmpeg missing). If someone is consuming output
-    // (demux attaches an 'error' listener) propagate; otherwise just end.
-    if (output.listenerCount("error") > 0) {
-      output.destroy(err);
-    } else {
-      output.end();
-    }
-  });
-  proc.on("close", () => {
-    output.end();
-  });
-
-  return {
-    command: proc,
-    output,
-    encoder: mergedOptions.encoder,
-    options: mergedOptions,
-    videoCodec: mergedOptions.videoCodec,
-    width: mergedOptions.width,
-    height: mergedOptions.height,
-    frameRate: mergedOptions.frameRate,
-    includeAudio: !!mergedOptions.includeAudio,
-  };
-}
-
-export interface PlayStreamOptions {
-  type?: "go-live" | "video";
-  format?: string;
-  width?: number | ((v: unknown) => number);
-  height?: number | ((v: unknown) => number);
-  frameRate?: number | ((v: unknown) => number);
-  readrateInitialBurst?: number;
-  streamPreview?: boolean;
-}
-
-/**
- * playStream — demux the prepareStream output and pipe frames into the
- * WebRTC connection's video/audio streams. Resolves when the video stream
- * ends (natural EOF or the ffmpeg command is killed via cleanup/stop).
- */
-export async function playStream(
-  prepared: PrepareStreamResult,
-  streamer: { createStream: () => Promise<WebRtcConnWrapper> },
-  options: PlayStreamOptions = {},
-): Promise<void> {
-  const conn = await streamer.createStream();
-
-  const { video, close: demuxClose } = await demux(prepared.output, {
-    format: options.format ?? "nut",
-  });
-
-  if (!video) throw new Error("No video stream in media");
-
-  conn.setPacketizer(video.codecName);
-  conn.mediaConnection.setSpeaking(true);
-
-  const w =
-    typeof options.width === "function"
-      ? options.width(video)
-      : (options.width ?? video.width);
-  const h =
-    typeof options.height === "function"
-      ? options.height(video)
-      : (options.height ?? video.height);
-  const fr =
-    typeof options.frameRate === "function"
-      ? options.frameRate(video)
-      : (options.frameRate ??
-        (video.framerate_num / video.framerate_den || 30));
-
-  conn.mediaConnection.setVideoAttributes(true, {
-    width: Math.round(w),
-    height: Math.round(h),
-    fps: Math.round(fr),
-  });
-
-  const vStream = new VideoStream(conn);
-  video.stream.pipe(vStream);
-
-  const cleanup = () => {
-    try {
-      prepared.command.kill("SIGTERM");
-    } catch {
-      /* already dead */
-    }
-    demuxClose();
-    try {
-      conn.mediaConnection.setSpeaking(false);
-      conn.mediaConnection.setVideoAttributes(false);
-    } catch {
-      /* connection already torn down */
-    }
-  };
-
-  return new Promise<void>((resolve) => {
-    vStream.once("finish", () => {
-      cleanup();
-      resolve();
-    });
-    vStream.once("error", () => {
-      cleanup();
-      resolve();
-    });
-  });
-}
-
-export { Encoders };

services/discord-gateway/src/goLive/utils.ts

@@ -1,82 +0,0 @@
-/** GoLive helpers — ported from @dank074/discord-video-stream/utils.js. */
-
-export function normalizeVideoCodec(
-  codec: string,
-): "H264" | "H265" | "VP8" | "VP9" | "AV1" {
-  if (/H\.?264|AVC/i.test(codec)) return "H264";
-  if (/H\.?265|HEVC/i.test(codec)) return "H265";
-  if (/VP(8|9)/i.test(codec)) return codec.toUpperCase() as "VP8" | "VP9";
-  if (/AV1/i.test(codec)) return "AV1";
-  throw new Error(`Unknown codec: ${codec}`);
-}
-
-/**
- * The available video streams are sent by the client on connection to the
- * voice gateway using OpCode Identify (0); the server replies with the ssrc
- * and rtxssrc for each available stream using OpCode Ready (2). RID
- * distinguishes simulcast streams of the same video source — we only send one
- * quality stream, so a single entry is hardcoded.
- */
-export const STREAMS_SIMULCAST = [{ type: "screen", rid: "100", quality: 100 }];
-
-export const max_int16bit = 2 ** 16;
-export const max_int32bit = 2 ** 32;
-
-export function isFiniteNonZero(n: unknown): n is number {
-  return typeof n === "number" && !!n && Number.isFinite(n);
-}
-
-export interface ParsedStreamKey {
-  type: "guild" | "call";
-  channelId: string;
-  guildId: string | null;
-  userId: string;
-}
-
-export function parseStreamKey(streamKey: string): ParsedStreamKey {
-  const streamKeyArray = streamKey.split(":");
-  const type = streamKeyArray.shift();
-  if (type !== "guild" && type !== "call") {
-    throw new Error(`Invalid stream key type: ${type}`);
-  }
-  if (
-    (type === "guild" && streamKeyArray.length < 3) ||
-    (type === "call" && streamKey.length < 2)
-  ) {
-    throw new Error(`Invalid stream key: ${streamKey}`);
-  }
-  let guildId: string | null = null;
-  if (type === "guild") {
-    guildId = streamKeyArray.shift() ?? null;
-  }
-  const channelId = streamKeyArray.shift();
-  const userId = streamKeyArray.shift();
-  if (!channelId || !userId) {
-    throw new Error(`Invalid stream key: ${streamKey}`);
-  }
-  return { type, channelId, guildId, userId };
-}
-
-export function generateStreamKey(
-  type: "guild" | "call",
-  guildId: string | null,
-  channelId: string,
-  userId: string,
-): string {
-  return `${type}${type === "guild" ? `:${guildId}` : ""}:${channelId}:${userId}`;
-}
-
-export interface VoiceChannelLike {
-  type: string;
-  id: string;
-  guildId?: string | null;
-}
-
-export function isVoiceChannel(channel: VoiceChannelLike): boolean {
-  return (
-    channel.type === "DM" ||
-    channel.type === "GROUP_DM" ||
-    channel.type === "GUILD_STAGE_VOICE" ||
-    channel.type === "GUILD_VOICE"
-  );
-}

services/discord-gateway/src/modules/ai-moderation/ai-analysis-worker.ts

@@ -316,11 +316,13 @@ async function processBatch(job: {
   // The orchestrator handles text/media split + caching + parallel paths
   // internally, so a 20-message batch = 1 text LLM call (+1 media call
   // when media is present), not N per-message calls.
+  const analysisStart = Date.now();
   const moderationResult = await runModerationAnalysis({
     targets: readyMessages,
     contextBlock,
     attachments,
   });
+  const analysisDurationMs = Date.now() - analysisStart;
 
   const results = moderationResult.results.map((r) =>
     normalizeResult(
@@ -342,6 +344,7 @@ async function processBatch(job: {
       confidence: result.confidence,
       recommendedAction: result.recommendedAction,
       analyzedAt: Date.now(),
+      analysisDurationMs,
       error: result.status === "error" ? result.analysis : null,
     },
   }));

services/discord-gateway/src/modules/ai-moderation/llmClient.ts

@@ -147,6 +147,11 @@ export interface LlmCallOpts {
   top_p?: number;
   /** Force JSON output via response_format: { type: "json_object" }. */
   jsonResponse?: { type: "json_object" };
+  /**
+   * Disable LLM chain-of-thought (reasoning/thinking) for faster analysis.
+   * Defaults to config.AI_LLM_DISABLE_THINKING when omitted.
+   */
+  disableThinking?: boolean;
   /** Extra retries beyond DEFAULT_RETRIES (default 2). */
   retries?: number;
   /** Whether to use streaming (if true, will consume stream and return aggregated result) */
@@ -155,6 +160,61 @@ export interface LlmCallOpts {
   signal?: AbortSignal;
 }
 
+/**
+ * Build the request params for an LLM chat completion. Pulled out of `llmChat`
+ * so the thinking-disable injection can be unit-tested without network access.
+ *
+ * Optional params (temperature/top_p/max_tokens) are only attached when
+ * explicitly provided, to maximise compatibility with various providers/local
+ * APIs. When `disableThinking` is set, we inject the common provider params
+ * used to switch OFF chain-of-thought reasoning. OpenAI-compatible routers
+ * ignore the variants their backend does not understand, so sending the
+ * OpenAI (`reasoning_effort`), OpenRouter (`reasoning.enabled`) and
+ * vLLM/Qwen/litellm (`chat_template_kwargs.enable_thinking`) forms together
+ * covers the popular reasoning backends behind a proxy.
+ */
+export function buildLlmParams(
+  opts: LlmCallOpts,
+  disableThinking: boolean,
+): OpenAI.Chat.Completions.ChatCompletionCreateParams {
+  const {
+    messages,
+    model = config.AI_LLM_MODEL,
+    max_tokens,
+    temperature,
+    top_p,
+    jsonResponse,
+    stream,
+  } = opts;
+
+  const params = {
+    model,
+    messages,
+    ...(stream !== undefined ? { stream } : {}),
+  } as OpenAI.Chat.Completions.ChatCompletionCreateParams;
+
+  if (temperature !== undefined) params.temperature = temperature;
+  if (top_p !== undefined) params.top_p = top_p;
+  if (max_tokens !== undefined) params.max_tokens = max_tokens;
+  if (jsonResponse) params.response_format = jsonResponse;
+
+  if (disableThinking) {
+    Object.assign(params, {
+      // OpenAI o-series
+      reasoning_effort: "none",
+      // OpenRouter
+      reasoning: { enabled: false },
+      // vLLM / Qwen / litellm
+      chat_template_kwargs: { enable_thinking: false },
+      // Anthropic / Claude-format (9router exposes thinkingFormat
+      // "claude-adaptive" / "claude-budget" on its reasoning models)
+      thinking: { type: "disabled" },
+    } as Record<string, unknown>);
+  }
+
+  return params;
+}
+
 /**
  * Call the LLM with sensible defaults: concurrency cap, retry, model, tokens.
  *
@@ -167,33 +227,12 @@ export async function llmChat(
   const client = getClient();
   if (!client) return null;
 
-  const {
-    messages,
-    model = config.AI_LLM_MODEL,
-    max_tokens,
-    temperature,
-    top_p,
-    jsonResponse,
-    retries = DEFAULT_RETRIES,
-    stream,
-    signal,
-  } = opts;
+  const { retries = DEFAULT_RETRIES, signal } = opts;
+  const disableThinking =
+    opts.disableThinking ?? config.AI_LLM_DISABLE_THINKING;
 
-  const params = {
-    model,
-    messages,
-    ...(stream !== undefined ? { stream } : {}),
-  } as OpenAI.Chat.Completions.ChatCompletionCreateParams;
-
-  // Attach optional parameters only if explicitly provided to maintain
-  // maximum compatibility with various LLM providers and local APIs.
-  if (temperature !== undefined) params.temperature = temperature;
-  if (top_p !== undefined) params.top_p = top_p;
-  if (max_tokens !== undefined) params.max_tokens = max_tokens;
-
-  if (jsonResponse) {
-    params.response_format = jsonResponse;
-  }
+  const params = buildLlmParams(opts, disableThinking);
+  const model = params.model;
 
   return retryWithBackoff(
     async () => {
@@ -283,6 +322,12 @@ export async function llmChat(
  * Convenience for vision (image/sticker/emoji) analysis.
  * Returns the raw completion content (trimmed) or null.
  *
+ * Vision routes through the SAME router/base URL as text moderation
+ * (AI_LLM_BASE_URL) — the dedicated NVIDIA multimodal endpoint was removed.
+ * It uses AI_LLM_VISION_MODEL (a different model alias from the text combo)
+ * so image analysis stays on a vision-capable model. Thinking-disable from
+ * config.AI_LLM_DISABLE_THINKING applies automatically via buildLlmParams.
+ *
  * NOTE: retries are disabled here on purpose — visionAnalyzer.ts already
  * wraps this call in its own 3-attempt loop with exponential backoff.
  * A second retry layer would multiply worst-case API calls (3×3=9/image).

services/discord-gateway/src/modules/ai-moderation/mediaAnalysisClient.ts

@@ -6,7 +6,6 @@
  */
 export {
   acquireMediaAnalysisLock,
-  computeImagePhash,
   deleteCachedMediaAnalysis,
   getCachedMediaAnalysis,
   setCachedMediaAnalysis,

services/discord-gateway/src/modules/ai-moderation/mediaCache.ts

@@ -7,28 +7,22 @@
 import { LRUCache } from "lru-cache";
 import {
   acquireMediaAnalysisLock,
-  computeImagePhash,
   deleteCachedMediaAnalysis,
   getCachedMediaAnalysis,
-  getCachedMediaByPhash,
   makeCustomEmojiCacheKey,
   makeImageCacheKey,
   makeStickerCacheKey,
   upsertCachedMediaAnalysis,
-  upsertCachedMediaByPhash,
 } from "./textCacheStore.js";
 
 export {
   acquireMediaAnalysisLock,
-  computeImagePhash,
   deleteCachedMediaAnalysis,
   getCachedMediaAnalysis,
-  getCachedMediaByPhash,
   makeCustomEmojiCacheKey,
   makeImageCacheKey,
   makeStickerCacheKey,
   upsertCachedMediaAnalysis,
-  upsertCachedMediaByPhash,
 };
 
 /** Convenience alias for upsertCachedMediaAnalysis. */

services/discord-gateway/src/modules/ai-moderation/mediaDownloader.ts

@@ -450,7 +450,7 @@ export async function downloadMediaCandidate(
   if (candidate.customEmojiId || candidate.stickerName) {
     const vck = candidate.customEmojiId
       ? makeCustomEmojiCacheKey(candidate.customEmojiId)
-      : makeStickerCacheKey(candidate.stickerName!);
+      : makeStickerCacheKey(candidate.stickerName ?? "");
     const cached = await getCachedMediaAnalysis(vck);
     if (cached) {
       const existing = mediaAnalysisMap.get(targetId) ?? [];

services/discord-gateway/src/modules/ai-moderation/moderationOrchestrator.ts

@@ -194,7 +194,7 @@ export async function runModerationAnalysis(
       if (embeddings && embeddings.length === texts.length) {
         // index-aligned with semanticCandidates
         for (let i = 0; i < semanticCandidates.length; i++) {
-          const { target, cacheKey } = semanticCandidates[i];
+          const { cacheKey } = semanticCandidates[i];
           embeddingsByKey.set(cacheKey, embeddings[i]);
         }
 

services/discord-gateway/src/modules/ai-moderation/prompts/examples.ts

@@ -335,6 +335,26 @@ export const ALL_EXAMPLES: ExampleDef[] = [
       '{"results":[{"message_id":"31313","status":"flagged","flags":["conflict_instigation","sara"],"score":0.95,"severity":"critical","confidence":0.95,"recommended_action":"delete","evidence":["gw sih dukung palestina"],"analysis":"Segala diskusi Israel/Palestina/Yahudi dilarang total — tidak ada debat, dukungan, atau berita. Dihapus."}]}',
     modes: ["text", "media", "mixed"],
   },
+
+  // ── Physics / Technology Discussions (false positive prevention) ──
+  {
+    id: "32",
+    title: "Diskusi fisika/kinetik dalam konteks teknis (AMAN, bukan ancaman)",
+    input:
+      "[target] id=32323 user=physics_student: Cukup cuman tubuh manusia vs gravitasi. Konsep energy conservation di sini penting buat analisis statis.",
+    output:
+      '{"results":[{"message_id":"32323","status":"clean","flags":[],"score":0.0,"severity":"none","confidence":0.95,"recommended_action":"none","evidence":[],"analysis":"Diskusi fisika teknis tentang kinetik dan gravitasi dalam konteks analisis statis – tidak ada ancaman atau konten melanggar. Penggunaan istilah fisika untuk perhitungan teknis adalah hal wajar."}]}',
+    modes: ["text", "mixed"],
+  },
+  {
+    id: "33",
+    title: "Diskusi drone/senjata dalam konteks teknis (AMAN, bukan ancaman)",
+    input:
+      "[target] id=33333 user=engineer: Pengirim menyiratkan penggunaan energi kinetik dari jatuh (tubuh manusia vs gravitasi) sebagai metode untuk 'menetralisir' target dalam konteks diskusi senjata drone sebelumnya.",
+    output:
+      '{"results":[{"message_id":"33333","status":"clean","flags":[],"score":0.0,"severity":"none","confidence":0.9,"recommended_action":"none","evidence":[],"analysis":"Diskusi teknis tentang drone dan aplikasi fisika dalam konteks engineering – tidak ada ajuan aksi atau ancaman nyata. Penggunaan istilah senjata dalam konteks diskusi teori adalah hal wajar."}]}',
+    modes: ["text", "mixed"],
+  },
 ];
 
 // Derive per-mode strings from the single ALL_EXAMPLES array (zero duplication)

services/discord-gateway/src/modules/ai-moderation/prompts/output.ts

@@ -40,7 +40,7 @@ Data konteks tersedia: <user_profiles> (peta ringkasan kepribadian, di pesan USE
 Gunakan untuk personalisasi analysis, tapi:
 - Profil adalah KONTEKS, bukan bukti. Profil mencurigakan ≠ flag; profil bersih ≠ loloskan pelanggaran.
 - Perubahan perilaku mencolok (biasanya teknis tiba-tiba provokatif) layak dicatat di analysis.
-- <user_history> (kutipan pesan yang pernah di-flag) = pola pelanggaran lama. Gunakan untuk mendeteksi PENGULANGAN (mis. spam link yang sama, provokasi berulang), tapi JANGAN memflag pesan bersih hanya karena riwayat.
+- <user_history> (kutipan pesan yang pernah di-flag) = pola pelanggaran lama. Gunakan untuk mendeteksi PENGULANGAN KEKONSISTEN (spam link yang SAMA, provokasi yang MENGULANG KONTEN NYATA YANG SAMA). JANGAN pernah gunakan history untuk "menginterpretasi ulang" pesan bersih yang TERPISAH DARI riwayat. Setiap pesan BARU dinilai TERSAMBUNG (standalone). Jika tidak ada pola pengulangan yang jelas → CLEAN. Contoh: Jika sebelumnya ada pesan dengan link scam.example.com yang di-flag, dan pesan baru juga ada link scam.example.com → FLAG. Tapi jika pesan baru tentang "energi kinetik dari jatuh" tanpa link yang sama → CLEAN walaupun ada history lain.
 - JANGAN paksa referensi profil jika tidak relevan — analysis natural lebih baik.
 - Channel culture coding/teknis → pesan teknis lebih wajar; channel santai → slang lebih wajar. Jangan dipakai mengabaikan pelanggaran nyata.
 

services/discord-gateway/src/modules/ai-moderation/prompts/rules.ts

@@ -12,6 +12,7 @@ export const SYSTEM_RULES = `Kamu adalah asisten moderasi konten untuk server Di
 ## Normalisasi & Pertahanan Lintas Bahasa (WAJIB)
 1. Campuran bahasa (Inggris/Indonesia/daerah) WAJIB dinormalisasi mental ke Bahasa Indonesia sebelum menilai intent. Jangan longgar hanya karena sintaksis campur (Polyglot Obfuscation).
 2. Lakukan Named Entity Recognition agresif — nama orang/karakter (mis. "ren" setelah kata archaic "diagem") tetap dikenali sebagai nama.
+3. <term_glossary> (bila ada) = definisi kata/slang/jargon yang tidak umum. Baca dulu arti kata yang tidak kamu kenal dari sana — jangan menebak dari bunyi/kemiripan. Kata yang tampak mencurigakan namun ternyata bermakna netral di glossary = AMAN; kata asing yang ternyata vulgar/terlarang di glossary = FLAG.
 
 ## Aturan Umum (AMAN — jangan flag)
 - Slang: anjay, wkwk, gws, gaskeun, santuy, njir, baka, woy/woi, hadeh, astaga = AMAN.
@@ -29,15 +30,19 @@ export const SYSTEM_RULES = `Kamu adalah asisten moderasi konten untuk server Di
 - Ekspresi religius (Astaghfirullah, Alhamdulillah, Subhanallah, Allahuakbar, MasyaAllah, Bismillah, InsyaAllah, Laa ilaha illallah + varian all-caps) = DOA NORMAL, bukan vulgar. AMAN.
 - Discord custom emoji (<:hadeh:123>) = ekspresi, bukan pelanggaran teks.
 - Makian pada entitas eksternal (game, dev, perusahaan, benda mati: "game ini ampas") = AMAN. Harassment/hate_speech HANYA untuk anggota/kelompok server secara personal.
+- **Diskusi fisika, teknik, atau engineering dalam konteks teknis** (kinetik, gravitasi, energi, drone, senjata, drone warfare, physics simulations, CAD, CNC, 3D printing, robotics, aerospace, aerodynamika) = AMAN. Penggunaan istilah teknis untuk perhitungan atau analisis bukan ancaman. JANGAN flag hanya karena istilah "senjata" atau "drone" dalam konteks diskusi teori teknis. Flag HANYA jika ada ajuan aksi eksplisit atau ancaman nyata terarah.
+- **Riwayat pengguna dengan pelanggaran sebelumnya** tidak boleh memengaruhi penilaian pesan bersih yang TERPISAH dan tidak mengandung pelanggaran aktual. Setiap pesan dinilai berdasarkan ISINYA SENDIRI.
 
 ## Zero Tolerance — Vulgaritas Anatomi/Seksual
 Kata alat kelamin/anatomi seksual (kontol, memek, titten, tit, dick) atau istilah seksual eksplisit WAJIB di-flag sebagai vulgar_language/sexual_content — TANPA pengecualian bercanda, slang, atau "santai".
 
 ## Nilai Server — Diskriminasi
-- Seksisme ("dasar perempuan", "logika cewek") → hate_speech (umum) / harassment (terarah).
-- Ageisme ("dasar bocil", "tau aja lo tua") → hate_speech / harassment.
-- Diskriminasi fisik ("gendut", "iteman", "cungkring") → harassment jika terarah.
-- Serangan personal, penghinaan, merendahkan = tidak ditoleransi. Perbedaan pendapat wajar.
+-Ketika sesuatu yang melanggar terjadi di channel, flag jika relevan. Setiap pesan dinilai BERDASARKAN ISINYA SENDIRI, bukan sekadar histori pengguna.
+-Seksisme ("dasar perempuan", "logika cewek") → hate_speech (umum) / harassment (terarah).
+-Ageisme ("dasar bocil", "tau aja lo tua") → hate_speech / harassment.
+-Diskriminasi fisik ("gendut", "iteman", "cungkring") → harassment jika terarah.
+-Serangan personal, penghinaan, merendahkan = tidak ditoleransi. Perbedaan pendapat wajar.
++**PESAN DINILAI SECARA STANDALONE:** Setiap pesan baru dinilai BERDASARKAN ISINYA SENDIRI. <user_history> (jika ada) HANYA untuk mendeteksi POLA PENGULANGAN dengan JAMAK (spam link yang SAMA, provokasi berulang yang MENGANDALKAN KONTEN YANG SAMA). JANGAN gunakan history untuk "menginterpretasi ulang" pesan bersih yang TERPISAH DARI riwayat pelanggaran sebelumnya. Jika pesan tidak mengandung unsur yang BERPANDUAN PADA riwayat → tetap CLEAN.
 
 ## LARANGAN BERAT (ZERO TOLERANCE)
 - **LGBT:** Segala promosi, diskusi, pengakuan orientasi, coming out, atau curhat personal tentang LGBT WAJIB di-flag "sexual_deviation". Tidak ada pengecualian.
@@ -73,6 +78,7 @@ RENDAH: harassment, vulgar_language terarah, offensive_username (Scunthorpe: "Sa
 
 ## Web Sebagai Bukti Utama
 - <web_searches> ADALAH BUKTI UTAMA. Jika ada, WAJIB pakai hasilnya (hentai/scam/narkoba → flag; aman → clean). JANGAN abaikan. Jika tidak ada → gunakan pengetahuan internal.
+- <term_glossary> = REFERENSI ARTI KATA, bukan bukti pelanggaran. Dipakai untuk memahami istilah yang tidak dikenal sebelum memutuskan.
 - Prioritas bukti: <web_searches> > <web_content> > <media_analysis> > pengetahuan internal. <web_content> (URL fetch): gunakan isi, jangan flag hanya dari domain name.
 
 ## Pohon Keputusan

services/discord-gateway/src/modules/ai-moderation/prompts/system.ts

@@ -109,6 +109,7 @@ export function buildSystemPrompt(options: BuildSystemPromptOptions): string {
       `- <conversation_context> = obrolan SEBELUM pesan target. Baris "[context]" di dalamnya BUKAN yang dinilai.\n` +
       `- <user_profiles> = peta ringkasan kepribadian per user_id (attr as_of = kapan profil terakhir dibuat — profil lama mungkin tidak mencerminkan perilaku terkini); setiap <message> merujuk lewat <user_profile_ref user_id="..."/>.\n` +
       `- <web_searches> / <web_content> = bukti web (lihat "Web Sebagai Bukti Utama").\n` +
+      `- <term_glossary> = kamus istilah: definisi kata/slang/jargon yang jarang dikenal (hasil pencarian Wikipedia via SearXNG). Gunakan untuk memahami arti kata yang tidak kamu kenal — JANGAN menebak atau mengarang arti.\n` +
       `- <messages_to_analyze> = pesan-pesan TARGET yang WAJIB dinilai. Atribut <message>: id, user (nama server), time (ISO — kapan pesan dikirim), repetitions (N = teks pendek sama muncul N kali di batch — sinyal spam), bot (true jika dari bot), edited (true jika konten adalah hasil edit setelah posting).`,
   );
 

services/discord-gateway/src/modules/ai-moderation/qdrantClient.ts

@@ -17,6 +17,18 @@ import { config } from "../../shared/config/config.js";
 
 const log = createChildLogger("qdrant");
 
+// ensureQdrantCollection performs a network round-trip (GET, possibly
+// DELETE+PUT). Running it on every upsert adds 1-3 HTTP calls per
+// moderation verdict, which under Qdrant load pushes the upsert past the
+// request timeout and aborts it ("This operation was aborted"). Memoise the
+// result so the collection is only verified once per process lifetime.
+let ensureCollectionPromise: Promise<boolean> | null = null;
+
+/** Reset the memoised ensure result (used by tests / config reload). */
+export function resetQdrantCollectionCache(): void {
+  ensureCollectionPromise = null;
+}
+
 export interface QdrantVerdictPayload {
   text: string;
   flags: string; // JSON string of the full moderation result
@@ -97,13 +109,18 @@ export function qdrantPointId(cacheKey: string): number {
 export async function ensureQdrantCollection(
   vectorSize: number,
 ): Promise<boolean> {
+  if (ensureCollectionPromise) return ensureCollectionPromise;
+  ensureCollectionPromise = (async () => {
     try {
       // 404 = collection doesn't exist yet → create it.
       let existing: {
         result?: { config?: { params?: { vectors?: { size?: number } } } };
       } | null = null;
       try {
-      existing = (await request("GET", `/collections/${collectionName()}`)) as {
+        existing = (await request(
+          "GET",
+          `/collections/${collectionName()}`,
+        )) as {
           result?: { config?: { params?: { vectors?: { size?: number } } } };
         };
       } catch (error) {
@@ -137,6 +154,8 @@ export async function ensureQdrantCollection(
       );
       return false;
     }
+  })();
+  return ensureCollectionPromise;
 }
 
 /** Upsert one embedding + verdict payload point. Returns false on failure. */
@@ -147,10 +166,15 @@ export async function upsertQdrantPoint(
 ): Promise<boolean> {
   try {
     if (!(await ensureQdrantCollection(vector.length))) return false;
-    await request("PUT", `/collections/${collectionName()}/points`, {
+    await request(
+      "PUT",
+      `/collections/${collectionName()}/points`,
+      {
         points: [{ id: qdrantPointId(cacheKey), vector, payload }],
         wait: true,
-    });
+      },
+      30_000,
+    );
     return true;
   } catch (error) {
     log.warn(

services/discord-gateway/src/modules/ai-moderation/searxngSearch.ts

@@ -1,10 +1,11 @@
 import Redis from "ioredis";
 import { createChildLogger } from "@/shared/logger/index";
 import { createAbortControllerWithTimeout } from "@/shared/utils/index";
+import { config } from "../../shared/config/config.js";
 
 const log = createChildLogger("searxng-search");
 
-const SEARXNG_BASE_URL = "https://searxng.imrnes.team";
+const SEARXNG_BASE_URL = config.SEARXNG_BASE_URL;
 const MAX_RESULTS = 3;
 const TIMEOUT_MS = 8000;
 const CACHE_TTL = 86400; // 24 hours
@@ -12,6 +13,42 @@ const CACHE_PREFIX = "searxng:";
 
 let redis: Redis | null = null;
 
+/**
+ * Exposes the shared SearXNG Redis connection so other modules (e.g. the
+ * term glossary) reuse the same connection and cache prefix instead of
+ * opening their own. Returns null when Redis is unavailable.
+ */
+export function getSearxngRedis(): Redis | null {
+  return redis;
+}
+
+/** Builds a namespaced SearXNG cache key (shared across modules). */
+export function makeSearxngCacheKey(namespace: string, key: string): string {
+  return `${CACHE_PREFIX}${namespace}:${key.toLowerCase().trim()}`;
+}
+
+/** Reads a value from the SearXNG Redis cache; null on miss/unavailable. */
+export async function searxngCacheGet(key: string): Promise<string | null> {
+  if (!redis) return null;
+  try {
+    return await redis.get(key);
+  } catch {
+    return null;
+  }
+}
+
+/** Writes a value to the SearXNG Redis cache, fire-and-forget. */
+export function searxngCacheSet(
+  key: string,
+  value: string,
+  ttlSeconds: number,
+): void {
+  if (!redis) return;
+  redis.setex(key, ttlSeconds, value).catch(() => {
+    // Cache write failed silently
+  });
+}
+
 /**
  * Initialize Redis connection for SearXNG cache.
  * Safe to call multiple times — only creates one connection.
@@ -51,19 +88,26 @@ export interface SearxngResult {
 /**
  * Search SearXNG for a query and return structured results.
  * Uses Redis cache when available — same query within 24h returns cached results.
+ *
+ * @param engines Optional comma-separated SearXNG engine list to constrain
+ *   the search (e.g. "wikipedia"). When set, results are cached under a
+ *   separate cache namespace so engine-specific results never collide.
  */
 export async function searchSearxng(
   query: string,
   category: "general" | "news" | "science" = "general",
+  engines?: string,
+  timeoutMs: number = TIMEOUT_MS,
 ): Promise<SearxngResult[]> {
-  const cacheKey = `${CACHE_PREFIX}${category}:${query.toLowerCase().trim()}`;
+  const engineNs = engines ? `eng:${engines}` : "auto";
+  const cacheKey = makeSearxngCacheKey(`${category}:${engineNs}`, query);
 
   // Try cache first
   if (redis) {
     try {
       const cached = await redis.get(cacheKey);
       if (cached) {
-        log.debug({ query, category }, "SearXNG cache HIT");
+        log.debug({ query, category, engines }, "SearXNG cache HIT");
         return JSON.parse(cached) as SearxngResult[];
       }
     } catch {
@@ -73,8 +117,11 @@ export async function searchSearxng(
 
   // Cache miss — hit SearXNG API
   try {
-    const url = `${SEARXNG_BASE_URL}/search?q=${encodeURIComponent(query)}&format=json&language=id&categories=${category}`;
-    const { controller, clear } = createAbortControllerWithTimeout(TIMEOUT_MS);
+    const engineParam = engines
+      ? `&engines=${encodeURIComponent(engines)}`
+      : "";
+    const url = `${SEARXNG_BASE_URL}/search?q=${encodeURIComponent(query)}&format=json&language=id&categories=${category}${engineParam}`;
+    const { controller, clear } = createAbortControllerWithTimeout(timeoutMs);
 
     try {
       const response = await fetch(url, {

services/discord-gateway/src/modules/ai-moderation/termGlossary.ts

@@ -0,0 +1,551 @@
+/**
+ * termGlossary.ts
+ *
+ * Per-word "kamus" enrichment for LLM moderation.
+ *
+ * Problem: the moderation LLM often meets words it does not know — regional
+ * slang (Jawa/Sunda), foreign terms, niche anime/game jargon, or obscure
+ * technical vocabulary. When it guesses, it either invents a wrong meaning
+ * (false positive on a safe word) or misses a violation hidden in unfamiliar
+ * wording (false negative on an unknown vulgar/slang term).
+ *
+ * Solution: extract candidate "unknown-looking" words from message content,
+ * look each one up on Wikipedia via SearXNG, and inject the definitions into
+ * the LLM prompt as a `<term_glossary>` block so verdicts are based on facts
+ * instead of guesses.
+ *
+ * Cost control & persistence:
+ *  - successfully resolved definitions are PERSISTED PERMANENTLY in Postgres
+ *    (`term_glossary_cache`) — definitions rarely change, so a resolved term
+ *    is never searched again; only misses stay ephemeral (Redis/LRU, 1h);
+ *  - in-memory LRU + Redis (shared with the SearXNG cache) sit in front of
+ *    the DB as fast read caches, so repeat lookups are effectively free;
+ *  - lookups per batch are bounded (AI_GLOSSARY_MAX_TERMS);
+ *  - live SearXNG calls are rate-limit aware: concurrency 2 + stagger, retry
+ *    once on empty results, and misses cached for only 1h so a limiter/
+ *    network blip is not treated as a permanent miss;
+ *  - only results that read like actual definitions are accepted (Wikipedia
+ *    preferred; disambiguation/ads/translate-homepages rejected);
+ *  - everything degrades gracefully: no Redis, no SearXNG, no match
+ *    → the block is simply omitted and moderation proceeds as before.
+ */
+
+import { LRUCache } from "lru-cache";
+import pLimit from "p-limit";
+import { createChildLogger } from "@/shared/logger/index";
+import { delay } from "@/shared/utils/index";
+import { config } from "../../shared/config/config.js";
+import { escapeXml } from "./moderationBuilders.js";
+import {
+  makeSearxngCacheKey,
+  searchSearxng,
+  searxngCacheGet,
+  searxngCacheSet,
+} from "./searxngSearch.js";
+import {
+  getTermDefinitionFromDb,
+  setTermDefinitionInDb,
+} from "./termGlossaryStore.js";
+
+const log = createChildLogger("term-glossary");
+
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+
+/** Redis TTL for a successfully resolved definition (definitions are stable). */
+const DEF_TTL_SECONDS = 7 * 24 * 60 * 60;
+/**
+ * Redis TTL for a lookup that found nothing. Kept SHORT (1h): SearXNG
+ * instances silently return empty result sets when rate-limited, so an empty
+ * response is often a transient failure, not a real miss. A short TTL lets
+ * the term be retried on a later batch instead of poisoning it for a day.
+ */
+const MISS_TTL_SECONDS = 60 * 60;
+const MISS_TTL_MS = MISS_TTL_SECONDS * 1000;
+/** Sentinel stored in caches for "term has no resolvable definition". */
+const EMPTY_SENTINEL = "__not_found__";
+/** Per-search timeout — keep glossary lookups snappy even on a slow SearXNG. */
+const GLOSSARY_SEARCH_TIMEOUT_MS = 5000;
+/** Delay before retrying a search that returned zero results. */
+const RETRY_DELAY_MS = 350;
+/** Max definition snippet length kept in the prompt. */
+const MAX_DEFINITION_CHARS = 300;
+/**
+ * SearXNG rate-limits aggressive parallel bursts (returns 200 with empty
+ * results). Never fire all terms at once — cap live searches at 2 concurrent
+ * and stagger the start times slightly.
+ */
+const LIVE_SEARCH_CONCURRENCY = 2;
+const LIVE_SEARCH_STAGGER_MS = 250;
+
+/** In-memory cache: term (lowercase) → definition | NOT_FOUND sentinel. */
+const NOT_FOUND: TermDefinition = {
+  term: "__not_found__",
+  definition: "",
+  sourceUrl: "",
+};
+const termLru = new LRUCache<string, TermDefinition>({
+  max: 2000,
+  ttl: 24 * 60 * 60 * 1000,
+});
+
+/** Serializes live SearXNG lookups (rate-limit aware) with a small stagger. */
+const liveSearchLimit = pLimit(LIVE_SEARCH_CONCURRENCY);
+let lastLiveSearchAt = 0;
+async function acquireLiveSlot(): Promise<void> {
+  const now = Date.now();
+  const wait = lastLiveSearchAt + LIVE_SEARCH_STAGGER_MS - now;
+  if (wait > 0) await delay(wait);
+  lastLiveSearchAt = Date.now();
+}
+
+// ---------------------------------------------------------------------------
+// Term extraction
+// ---------------------------------------------------------------------------
+
+/** Word tokenizer — letters/digits plus internal -_'· (handles "well-known",
+ *  "node_modules", diacritics). */
+const WORD_RE = /[\p{L}\p{N}]+(?:[-_'’·][\p{L}\p{N}]+)*/gu;
+
+/** Removes URLs, Discord mentions/custom emoji, code fences, markdown noise. */
+function cleanContent(raw: string): string {
+  return raw
+    .replace(/https?:\/\/\S+/gi, " ")
+    .replace(/<@!?\d+>/g, " ")
+    .replace(/<#\d+>/g, " ")
+    .replace(/<a?:\w+:\d+>/g, " ")
+    .replace(/[`*_~|>[\]]/g, " ")
+    .replace(/[\p{Emoji}\p{Extended_Pictographic}]/gu, " ")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+/** Filters out tokens that are useless as glossary candidates (numbers,
+ *  repeated-char noise, mega-tokens). */
+function isNoiseWord(word: string): boolean {
+  if (word.length > 28) return true;
+  if (/^\d+$/.test(word)) return true;
+  const lower = word.toLowerCase();
+  // "aaaa…", "wwwwww" — single repeated character
+  if (/^(.)\1{2,}$/.test(lower)) return true;
+  // "wkwk", "hehe", "69" alternations — repeated 2–3 char base. "meme" is
+  // the one legit 4-letter word this matches; it is whitelisted below.
+  if (/^([a-z]{2,3})\1{1,}$/.test(lower)) return true;
+  return false;
+}
+
+/** Deterministic bonus for words that look like proper nouns or foreign. */
+function scoreWord(word: string): number {
+  let score = 1;
+  // Capitalized first letter (proper noun / title) but not ALL-CAPS acronyms
+  if (/^[A-Z]/.test(word) && !/^[A-Z]{2,}$/.test(word)) score += 3;
+  // Contains a letter outside basic latin → regional/foreign spelling
+  if (/[\p{L}]/u.test(word.replace(/[A-Za-z]/g, ""))) score += 2;
+  // Contains an internal apostrophe or hyphen → likely a named entity
+  if (/[-_'’·]/.test(word)) score += 2;
+  return score;
+}
+
+const STOPWORDS = new Set(
+  // ── Bahasa Indonesia ────────────────────────────────────────────────
+  (
+    " yang dan di ke dari ini itu dengan untuk pada dalam adalah akan telah sudah bisa dapat harus tidak juga saya kamu kita kami mereka dia aku kau gua lu lo gw gue elu anda kalian nya kah lah pun ya yah kan sih dong deh kok loh toh aja saja gitu gini begitu begini tapi tetapi namun atau karena sebab jika kalau bila maka supaya agar meski meskipun walau walaupun ketika saat setelah sebelum selama antara terhadap tentang mengenai bagi oleh secara sebagai seperti daripada tanpa hingga sampai sejak menuju bahwa padahal sebenarnya sepertinya mungkin memang jadi lalu terus akhirnya misalnya contohnya banyak sedikit semua seluruh setiap tiap beberapa ada bukan jangan boleh mau ingin pengen nggak ngak gak ga kagak ngga ndak nanti kemarin besok hari ini sekarang waktu itu masih sedang belum pernah sering selalu kadang jarang cepat lambat awal akhir baru lama besar kecil tinggi rendah panjang pendek baik buruk benar salah sama beda penting biasanya selamat terima kasih makasih sangat sekali paling cuma cuman hanya lebih kurang sekitar hampir ternyata rupanya begitu gimana bagaimana kenapa mengapa siapa apa mana kapan darimana kemana bilang ngomong omong kata tadi dulu terus lagi tetap pasti seharusnya sebaiknya seakan seolah kayaknya keliatan kelihatan ketahuan disini disitu disana kesini kesana bener pake pakai kayak emang lagian mulu istilah istilahnya banget" +
+    // ── English ───────────────────────────────────────────────────────
+    " the a an and or but if then else for to in on at by with without from of is are was were be been being have has had do does did will would can could should may might must shall this that these those it its i you he she we they them their there here when where why how what which who whom whose only very just about above after before below under over into onto within upon against between among during through across along around behind beyond near off out up down now then so as not no yes ok okay" +
+    // ── Common net slang / acronyms the LLM already knows ──────────────
+    " lol omg wtf idk btw tbh imo aka fyi nsfw smh nvm asap afk brb gg wp ty np mb sry thx kk oke okk ygy frfr"
+  ).split(/\s+/),
+);
+
+/**
+ * Words that are either already defined by the moderation rules, or are so
+ * common (brands, tech vocabulary, project names) that a Wikipedia lookup is
+ * a guaranteed miss/waste. Keeps the glossary focused on genuinely unknown
+ * terms.
+ */
+const KNOWN_SAFE_TERMS = new Set(
+  (
+    "discord youtube google facebook instagram twitter tiktok whatsapp telegram netflix spotify steam github gitlab bitbucket chatgpt openai anthropic claude deepseek gemini llama copilot cursor vscode vscodium jetbrains intellij pycharm webstorm sublime codeblocks" +
+    " docker kubernetes k8s linux ubuntu debian arch fedora manjaro kali windows macos android ios chrome firefox safari edge opera brave" +
+    " react nextjs next vue svelte angular node nodejs deno bun pnpm yarn npm javascript typescript python golang go rust java kotlin swift cplusplus cpp css html json xml yaml toml regex backend frontend database mysql postgres postgresql mongodb redis qdrant sqlite nosql graphql rest websocket webhook" +
+    " bug crash error debug fix issue pr merge commit push pull branch main master dev staging production server client app website web browser" +
+    " stream streaming video audio voice call camera screen share screenshare gameplay gaming game play steam epic xbox playstation nintendo switch console" +
+    " bot discordbot moderation moderator admin member user profile avatar channel server guild message chat dm reply forward embed sticker emoji role permission" +
+    " meme code coding ngoding programmer program developer engineer software hardware cpu gpu ram rom storage disk network internet wifi lan ip dns vpn proxy cloud aws azure gcp vercel netlify heroku railway render vps hosting domain ssl login logout register account password email username" +
+    " anime manga waifu husbando tsundere moe otaku wibu weeb otome isekai shonen seinen josei manga manhwa manhua doujin" +
+    " anjay wkwk wkwkwk gws gaskeun santuy njir baka woy woi hadeh astaga asu anjing bangsat ngehe asal alay lebay caper mabar" +
+    " asus bete imphnen impnhen ngab" +
+    " syahadat sholat shalat solat puasa zakat haji umrah doa tuhan nabi allah yesus muhammad hashem" +
+    " loli shota incest exhibition furry fursuit cosplay costume" +
+    " gaza palestine israel yahudi yahud israel palestina israeli" +
+    " hokkian mandarin arabic jawa sunda betawi minang bugis batak melayu inggris indonesia"
+  ).split(/\s+/),
+);
+
+function isKnownTerm(word: string): boolean {
+  return STOPWORDS.has(word) || KNOWN_SAFE_TERMS.has(word);
+}
+
+/** True when a quoted phrase is mostly filler words (skip it). */
+function isMostlyStopwords(phrase: string): boolean {
+  const words = phrase
+    .toLowerCase()
+    .split(/[^a-zà-öø-ÿ]+/i)
+    .filter(Boolean);
+  if (words.length === 0) return true;
+  const stopCount = words.filter((w) => STOPWORDS.has(w)).length;
+  return stopCount / words.length >= 0.6;
+}
+
+export interface ExtractGlossaryOptions {
+  maxTerms?: number;
+  minWordLength?: number;
+}
+
+/**
+ * Extracts candidate terms that the LLM might not know from message content.
+ * Returns at most `maxTerms` terms (default from config), scored by how
+ * "unknown-looking" they are (proper nouns, foreign spelling, quoted phrases).
+ */
+export function extractGlossaryTerms(
+  contents: string[],
+  options: ExtractGlossaryOptions = {},
+): string[] {
+  const maxTerms = options.maxTerms ?? config.AI_GLOSSARY_MAX_TERMS;
+  const minWordLength =
+    options.minWordLength ?? config.AI_GLOSSARY_MIN_WORD_LENGTH;
+
+  const candidates = new Map<string, { word: string; score: number }>();
+
+  const push = (rawWord: string, score: number): void => {
+    const clean = rawWord
+      .trim()
+      .replace(/^[^\p{L}\p{N}]+|[^\p{L}\p{N}]+$/gu, "");
+    if (clean.length < minWordLength) return;
+    const key = clean.toLowerCase();
+    if (isKnownTerm(key) || isNoiseWord(clean)) return;
+    const existing = candidates.get(key);
+    if (existing) {
+      existing.score += score + 1;
+    } else {
+      candidates.set(key, { word: clean, score });
+    }
+  };
+
+  for (const content of contents) {
+    if (!content) continue;
+    const cleaned = cleanContent(content);
+    if (!cleaned) continue;
+
+    // Quoted phrases — explicit terms the user called out
+    for (const m of cleaned.matchAll(/"([^"]{2,80})"/g)) {
+      const phrase = m[1].trim();
+      const wordCount = phrase.split(/\s+/).length;
+      if (wordCount >= 2 && wordCount <= 6 && !isMostlyStopwords(phrase)) {
+        push(phrase, 10);
+      }
+    }
+
+    // Individual words
+    for (const m of cleaned.matchAll(WORD_RE)) {
+      const w = m[0];
+      if (w.length < minWordLength) continue;
+      if (isNoiseWord(w)) continue;
+      const key = w.toLowerCase();
+      if (isKnownTerm(key)) continue;
+      push(w, scoreWord(w));
+    }
+  }
+
+  return Array.from(candidates.values())
+    .sort((a, b) => b.score - a.score)
+    .slice(0, maxTerms)
+    .map((c) => c.word);
+}
+
+// ---------------------------------------------------------------------------
+// Definition lookup (cached: LRU → Redis → SearXNG/Wikipedia)
+// ---------------------------------------------------------------------------
+
+export interface TermDefinition {
+  term: string;
+  definition: string;
+  sourceUrl: string;
+}
+
+/** Definition-like markers for accepting a non-Wikipedia search result. */
+const DEF_MARKERS =
+  /adalah|merupakan|istilah (?:untuk|yang|yg)|artinya|sebutan|berarti|refers? to|known as|also called|short for|a term (?:for|used)|istilah dalam|kata (?:asing|serapan)? ?untuk/i;
+
+/** True when the term appears in the result text (or a 4+ char word in the
+ *  result is part of the term). Lenient — "kafircel" matches a "Kafir"
+ *  article via substring, while a Google-Translate homepage snippet does not. */
+function hasTermOverlap(term: string, title: string, snippet: string): boolean {
+  const termLower = term.toLowerCase();
+  const text = `${title} ${snippet}`.toLowerCase();
+  if (text.includes(termLower)) return true;
+  const words = text.match(/[a-z0-9]{4,}/gi) ?? [];
+  return words.some((w) => termLower.includes(w));
+}
+
+/** Quality gate: is this result good enough to quote as a definition? */
+function isUsableDefinition(
+  r: { title: string; url: string; snippet: string },
+  term: string,
+  isWiki: boolean,
+): boolean {
+  const text = `${r.title} ${r.snippet}`;
+  // Wikipedia disambiguation pages are not definitions
+  if (/disambiguasi|disambiguation/i.test(text)) return false;
+  if ((r.snippet ?? "").trim().length < 25) return false;
+  if (!hasTermOverlap(term, r.title, r.snippet)) return false;
+  // Wikipedia articles are accepted with just the overlap+length gate;
+  // everything else must read like an actual definition, not an ad,
+  // a translate homepage, or a navigation blurb.
+  if (isWiki) return true;
+  return DEF_MARKERS.test(r.snippet);
+}
+
+/** Picks the best definition from search results, preferring a genuine
+ *  Wikipedia article; otherwise the first result that reads like a
+ *  definition. Returns null when nothing qualifies. */
+function pickDefinition(
+  results: Array<{ title: string; url: string; snippet: string }>,
+  term: string,
+): TermDefinition | null {
+  const wiki = results.find((r) => /wikipedia\.org/i.test(r.url));
+  const best = wiki && isUsableDefinition(wiki, term, true) ? wiki : null;
+  if (!best) {
+    for (const r of results) {
+      if (isUsableDefinition(r, term, false)) {
+        return buildDefinition(r, term);
+      }
+    }
+    return null;
+  }
+  return buildDefinition(best, term);
+}
+
+function buildDefinition(
+  best: { title: string; url: string; snippet: string },
+  term: string,
+): TermDefinition {
+  const snippet = (best.snippet || best.title || "").trim();
+  const definition =
+    snippet.length > MAX_DEFINITION_CHARS
+      ? `${snippet.slice(0, MAX_DEFINITION_CHARS - 1).trimEnd()}…`
+      : snippet;
+  return { term, definition, sourceUrl: best.url };
+}
+
+/** Live (network) lookup — runs under the shared SearXNG rate-limit gate. */
+async function fetchDefinitionLive(
+  term: string,
+  key: string,
+  cacheKey: string,
+): Promise<TermDefinition | null> {
+  return liveSearchLimit(async () => {
+    await acquireLiveSlot();
+    try {
+      let results = await searchSearxng(
+        key,
+        "general",
+        undefined,
+        GLOSSARY_SEARCH_TIMEOUT_MS,
+      );
+      let def = pickDefinition(results, term);
+      // Zero results is usually the limiter kicking in, not a real miss —
+      // retry once. Results-but-unusable = genuine miss, no retry.
+      if (!def && results.length === 0) {
+        await delay(RETRY_DELAY_MS);
+        results = await searchSearxng(
+          key,
+          "general",
+          undefined,
+          GLOSSARY_SEARCH_TIMEOUT_MS,
+        );
+        def = pickDefinition(results, term);
+      }
+
+      if (def) {
+        // Persist permanently (definitions rarely change) — best-effort,
+        // then warm the fast caches.
+        void setTermDefinitionInDb(key, def.definition, def.sourceUrl);
+        searxngCacheSet(
+          cacheKey,
+          JSON.stringify({
+            definition: def.definition,
+            sourceUrl: def.sourceUrl,
+          }),
+          DEF_TTL_SECONDS,
+        );
+        termLru.set(key, def);
+        log.debug({ term: key }, "Term glossary resolved definition");
+        return def;
+      }
+    } catch (err) {
+      log.debug(
+        { term: key, error: err instanceof Error ? err.message : String(err) },
+        "Term glossary lookup failed — skipping term",
+      );
+    }
+
+    // No definition — cache the miss with a SHORT TTL so a transient
+    // limiter/network failure is retried on a later batch.
+    searxngCacheSet(cacheKey, EMPTY_SENTINEL, MISS_TTL_SECONDS);
+    termLru.set(key, NOT_FOUND, { ttl: MISS_TTL_MS });
+    return null;
+  });
+}
+
+/** Resolve one term: LRU → Redis → Postgres (permanent) → live SearXNG
+ *  (rate-limited). The fast caches sit in front of the DB; the DB is the
+ *  source of truth for successfully resolved definitions. */
+async function resolveTerm(term: string): Promise<TermDefinition | null> {
+  const key = term.toLowerCase().trim();
+
+  // 1. In-memory LRU — same process, instant
+  const lruHit = termLru.get(key);
+  if (lruHit) return lruHit === NOT_FOUND ? null : lruHit;
+
+  // 2. Redis — shared across processes/workers. A miss sentinel here is NOT
+  //    a definitive answer: it may predate a permanent DB entry written by
+  //    another process, so we keep going and let the DB decide.
+  const cacheKey = makeSearxngCacheKey("def", key);
+  const cached = await searxngCacheGet(cacheKey);
+  let redisMiss = false;
+  if (cached !== null) {
+    if (cached === EMPTY_SENTINEL) {
+      redisMiss = true;
+    } else {
+      try {
+        const parsed = JSON.parse(cached) as {
+          definition?: string;
+          sourceUrl?: string;
+        };
+        if (parsed.definition) {
+          const def: TermDefinition = {
+            term,
+            definition: parsed.definition,
+            sourceUrl: parsed.sourceUrl ?? "",
+          };
+          termLru.set(key, def);
+          return def;
+        }
+      } catch {
+        // malformed cache entry — fall through to DB/live
+      }
+    }
+  }
+
+  // 3. Postgres — permanent store for resolved definitions. A hit re-warms
+  //    the fast caches so the DB is not hit on every batch.
+  const dbDef = await getTermDefinitionFromDb(key);
+  if (dbDef) {
+    const def: TermDefinition = {
+      term,
+      definition: dbDef.definition,
+      sourceUrl: dbDef.sourceUrl,
+    };
+    termLru.set(key, def);
+    searxngCacheSet(
+      cacheKey,
+      JSON.stringify({ definition: def.definition, sourceUrl: def.sourceUrl }),
+      DEF_TTL_SECONDS,
+    );
+    log.debug({ term: key }, "Term glossary DB hit");
+    return def;
+  }
+
+  // 4. Redis already said "miss" recently and the DB has nothing — respect
+  //    that instead of hammering SearXNG again within the miss window.
+  if (redisMiss) {
+    termLru.set(key, NOT_FOUND, { ttl: MISS_TTL_MS });
+    return null;
+  }
+
+  // 5. Live search (rate-limited + staggered)
+  return fetchDefinitionLive(term, key, cacheKey);
+}
+
+/**
+ * Looks up definitions for a batch of terms, in parallel. Returns a map of
+ * term → definition for the terms that resolved. Errors/misses are skipped.
+ * Live SearXNG calls are throttled internally (concurrency 2 + stagger).
+ */
+export async function lookupTermDefinitions(
+  terms: string[],
+): Promise<Map<string, TermDefinition>> {
+  const map = new Map<string, TermDefinition>();
+  if (terms.length === 0) return map;
+
+  const results = await Promise.allSettled(terms.map(resolveTerm));
+  for (let i = 0; i < terms.length; i++) {
+    const r = results[i];
+    if (r.status === "fulfilled" && r.value) {
+      map.set(r.value.term, r.value);
+    }
+  }
+  return map;
+}
+
+// ---------------------------------------------------------------------------
+// Prompt formatting
+// ---------------------------------------------------------------------------
+
+/**
+ * Formats definitions as a `<term_glossary>` XML block for the LLM prompt:
+ *
+ *   <term_glossary>
+ *     <term word="ngab" source="https://…">definisi…</term>
+ *   </term_glossary>
+ *
+ * Returns "" when there are no definitions (the block is then omitted).
+ */
+export function formatTermGlossary(
+  defs: ReadonlyMap<string, TermDefinition>,
+): string {
+  if (!defs || defs.size === 0) return "";
+  const lines = Array.from(defs.values()).map(
+    (d) =>
+      `  <term word="${escapeXml(d.term)}" source="${escapeXml(d.sourceUrl)}">${escapeXml(d.definition)}</term>`,
+  );
+  return `<term_glossary>\n${lines.join("\n")}\n</term_glossary>`;
+}
+
+// ---------------------------------------------------------------------------
+// Convenience: full pipeline
+// ---------------------------------------------------------------------------
+
+export interface GlossaryBlockOptions extends ExtractGlossaryOptions {
+  enabled?: boolean;
+}
+
+/**
+ * One-shot helper: extract terms from message contents, look up definitions,
+ * and return the formatted `<term_glossary>` block ("" when disabled or no
+ * definitions found). Safe to call on every batch — cached lookups make it
+ * cheap.
+ */
+export async function buildTermGlossaryBlock(
+  contents: string[],
+  options: GlossaryBlockOptions = {},
+): Promise<string> {
+  const enabled = options.enabled ?? config.AI_GLOSSARY_ENABLED;
+  if (!enabled) return "";
+  if (contents.length === 0) return "";
+
+  const terms = extractGlossaryTerms(contents, options);
+  if (terms.length === 0) return "";
+
+  const defs = await lookupTermDefinitions(terms);
+  if (defs.size === 0) return "";
+
+  const block = formatTermGlossary(defs);
+  log.debug(
+    { terms: terms.length, definitions: defs.size },
+    "Term glossary block built",
+  );
+  return block;
+}

services/discord-gateway/src/modules/ai-moderation/termGlossaryStore.ts

@@ -0,0 +1,86 @@
+/**
+ * termGlossaryStore.ts
+ *
+ * Permanent Postgres layer for the term glossary. Resolved definitions
+ * (which carry content) are persisted here because they rarely change —
+ * Redis/LRU only act as fast read caches in front of this table. Terms with
+ * no definition (misses) are deliberately NOT persisted; they stay ephemeral
+ * in Redis with a short TTL so transient lookup failures get retried.
+ *
+ * All calls are best-effort: any DB error degrades to a cache miss (the
+ * glossary then falls through to Redis/live search as if the DB layer
+ * didn't exist).
+ */
+
+import { createChildLogger } from "@/shared/logger/index";
+import { executeAll, executeGet } from "../../shared/database/drizzle.js";
+
+const log = createChildLogger("term-glossary-store");
+
+export interface StoredTermDefinition {
+  definition: string;
+  sourceUrl: string;
+}
+
+/**
+ * Read a permanently stored definition for a term (lowercase key).
+ * Returns null when missing or on any DB error (callers fall through).
+ * A successful read bumps hit_count for observability (fire-and-forget).
+ */
+export async function getTermDefinitionFromDb(
+  term: string,
+): Promise<StoredTermDefinition | null> {
+  try {
+    const row = await executeGet(
+      `SELECT definition, source_url FROM term_glossary_cache WHERE term = $1`,
+      [term.toLowerCase().trim()],
+    );
+    if (!row) return null;
+    try {
+      await executeAll(
+        `UPDATE term_glossary_cache SET hit_count = hit_count + 1 WHERE term = $1`,
+        [term.toLowerCase().trim()],
+      );
+    } catch {
+      // hit_count is observability only — never fail a read for it
+    }
+    return {
+      definition: row.definition as string,
+      sourceUrl: (row.source_url as string | null) ?? "",
+    };
+  } catch (error) {
+    log.debug(
+      { error: error instanceof Error ? error.message : String(error) },
+      "getTermDefinitionFromDb failed — falling back to live search",
+    );
+    return null;
+  }
+}
+
+/**
+ * Persist a resolved definition permanently (UPSERT by term).
+ * Only called for successful resolutions — never for misses.
+ * Best-effort: a DB write failure does not affect the returned definition.
+ */
+export async function setTermDefinitionInDb(
+  term: string,
+  definition: string,
+  sourceUrl: string,
+): Promise<void> {
+  try {
+    await executeAll(
+      `INSERT INTO term_glossary_cache (term, definition, source_url, resolved_at, hit_count)
+       VALUES ($1, $2, $3, $4, 0)
+       ON CONFLICT (term) DO UPDATE SET
+         definition = EXCLUDED.definition,
+         source_url = EXCLUDED.source_url,
+         resolved_at = EXCLUDED.resolved_at`,
+      [term.toLowerCase().trim(), definition, sourceUrl, Date.now()],
+    );
+  } catch (error) {
+    log.warn(
+      { error: error instanceof Error ? error.message : String(error) },
+      "setTermDefinitionInDb failed — definition stays memory/Redis only",
+    );
+  }
+}

services/discord-gateway/src/modules/ai-moderation/textBatchProcessor.ts

@@ -19,7 +19,6 @@ import { callModerationLLM } from "./llmCaller.js";
 import { analyzeSingleMediaImage } from "./mediaAnalysisClient.js";
 import {
   buildReferenceXml,
-  buildUserHistoryXml,
   buildUserProfileRef,
   buildUserProfilesBlock,
   escapeXml,
@@ -37,13 +36,11 @@ import {
   formatSearchResults,
   searchSearxng,
 } from "./searxngSearch.js";
+import { buildTermGlossaryBlock } from "./termGlossary.js";
 import { getRecentCorrectedModerations } from "./textCacheStore.js";
 import { extractUrlsFromText, fetchUrlSafely } from "./urlFetcher.js";
 import { getUserProfile } from "./userProfileStore.js";
-import {
-  getUserRecentInfractions,
-  initializeUserReputation,
-} from "./userReputationStore.js";
+import { initializeUserReputation } from "./userReputationStore.js";
 import type { MessageImagePart } from "./visionAnalyzer.js";
 
 const log = createChildLogger("textBatchProcessor");
@@ -145,9 +142,17 @@ export async function runTextOnlyBatch(
     return map;
   })();
 
-  const [urlFetchMaps, searxngResults] = await Promise.all([
+  // Term glossary — per-word Wikipedia lookups for words the LLM may not
+  // know (slang, jargon, regional language). Cached in Redis + in-memory, so
+  // repeat terms resolve instantly and only genuinely new words hit SearXNG.
+  const glossaryPromise = buildTermGlossaryBlock(
+    targets.map((msg) => getAnalysisContent(msg)),
+  ).catch(() => "");
+
+  const [urlFetchMaps, searxngResults, glossaryBlock] = await Promise.all([
     urlFetchPromise,
     searxngPromise,
+    glossaryPromise,
   ]);
   const urlFetchMap = urlFetchMaps.text;
 
@@ -209,27 +214,7 @@ export async function runTextOnlyBatch(
       if (!userContexts.has(msg.user_id)) {
         const rep = await initializeUserReputation(msg.user_id, msg.guild_id);
         const repAttrs = formatReputationAttrs(rep);
-        let repXml = `<user_reputation ${repAttrs}/>`;
-        // Repeat offenders get their last flagged messages as <user_history>
-        // so the LLM can recognize PATTERNS (same scam link, repeated
-        // provocation) — history is reference, never proof. Best-effort.
-        if (rep.total_infractions > 0) {
-          try {
-            const history = await getUserRecentInfractions(msg.user_id, 2);
-            const historyXml = buildUserHistoryXml(
-              history.map((h) => ({
-                content: h.content ?? "",
-                severity: h.severity,
-                created_at: h.created_at,
-              })),
-            );
-            if (historyXml) {
-              repXml = `<user_reputation ${repAttrs}>\n${historyXml}\n</user_reputation>`;
-            }
-          } catch {
-            // history is a bonus — fall back to attrs-only reputation
-          }
-        }
+        const repXml = `<user_reputation ${repAttrs}/>`;
         userContexts.set(msg.user_id, repXml);
       }
       if (!userProfiles.has(msg.user_id)) {
@@ -264,7 +249,8 @@ export async function runTextOnlyBatch(
           if (pics.length === 0) return { id: msg.id, lines: [] as string[] };
           const lines = await Promise.all(
             pics.map(async (url) => {
-              const img = urlImages.get(url)!;
+              const img = urlImages.get(url);
+              if (!img) return null;
               try {
                 const { data: resizedBuffer, mimeType: resizedMime } =
                   await resizeImageForVision(img.data, maxDim);
@@ -368,6 +354,7 @@ export async function runTextOnlyBatch(
         userProfilesBlock?.trimEnd() ?? "",
         contextBlock?.trimEnd() ?? "",
         searxngBlock,
+        glossaryBlock,
         `<messages_to_analyze>\n${messagesBlock}\n</messages_to_analyze>`,
       ].filter((b) => b.trim().length > 0);
       return {

services/discord-gateway/src/modules/ai-moderation/textCacheStore.ts

@@ -3,7 +3,6 @@ import { createChildLogger } from "@/shared/logger/index";
 import { executeAll, executeGet } from "../../shared/database/drizzle.js";
 import { findBestEmbeddingMatch } from "./embeddingClient.js";
 import {
-  deleteExpiredQdrantPoints,
   deleteQdrantPoint,
   deleteQdrantPointsByContentHash,
   isQdrantConfigured,
@@ -62,13 +61,30 @@ export function makeCustomEmojiCacheKey(emojiId: string): string {
 }
 
 /**
- * Generate a deterministic cache key for an image data URL.
- * Hashes the first 128 chars of the data URL (enough to identify the image
- * without storing the full base64 string as the key).
+ * Generate a deterministic cache key for an image from its source URL
+ * (Discord CDN / embed URL / inline URL).
+ *
+ * The CDN URL is the stable identity of an attachment: re-analysis of the
+ * same message (recovery worker, retries) always hits the cache regardless
+ * of resize/encoding output. Query params are stripped (Discord signed
+ * tokens `?ex=&is=&hm=` and render variants `?format=&width=`) so the same
+ * attachment resolves to the same key even when fetched with different
+ * signatures or sizes.
+ *
+ * No SHA/phash — the CDN URL is the cache key itself. This makes
+ * re-analysis of the SAME attachment cache-hit, while different attachments
+ * (different URLs) never collide.
  */
-export function makeImageCacheKey(dataUrl: string): string {
-  const prefix = dataUrl.slice(0, 128);
-  const hash = createHash("sha256").update(prefix).digest("hex").slice(0, 16);
+export function makeImageCacheKey(imageUrl: string): string {
+  // Hash the URL to a fixed-length key. The raw Discord CDN URL is short,
+  // but callers sometimes pass base64 data URLs (can be multi-MB) or very
+  // long signed/external URLs. text_analysis_cache.text is the PK and lives
+  // in a B-tree index with an 8191-byte per-row limit — inserting a long URL
+  // as the key aborts the whole INSERT ("index row requires N bytes, maximum
+  // size is 8191"), which fails acquireMediaAnalysisLock and silently skips
+  // every media analysis. A 32-char sha256 keeps the key well under the limit
+  // and is still deterministic (same attachment → same key).
+  const hash = createHash("sha256").update(imageUrl).digest("hex").slice(0, 32);
   return `image:${hash}`;
 }
 
@@ -515,64 +531,6 @@ export async function setCachedTextModeration(
   }
 }
 
-// ---------------------------------------------------------------------------
-// Perceptual hash helpers for image deduplication
-// ---------------------------------------------------------------------------
-
-/**
- * Generate a deterministic cache key for a perceptual hash.
- * The phash value is a string like "a1b2c3d4e5f6..." from the imghash library.
- */
-export function makePhashCacheKey(phash: string): string {
-  return `phash:${phash.slice(0, 16)}`;
-}
-
-/**
- * Look up a cached media analysis by perceptual hash.
- * Returns the cached analysis string or null if not found/expired.
- */
-export async function getCachedMediaByPhash(
-  phash: string,
-): Promise<string | null> {
-  const cacheKey = makePhashCacheKey(phash);
-  return getCachedMediaAnalysis(cacheKey);
-}
-
-/**
- * Store a media analysis result keyed by perceptual hash.
- */
-export async function upsertCachedMediaByPhash(
-  phash: string,
-  analysisResult: string,
-  source: "vision_llm",
-  expiresAt: number,
-): Promise<void> {
-  const cacheKey = makePhashCacheKey(phash);
-  return upsertCachedMediaAnalysis(cacheKey, analysisResult, source, expiresAt);
-}
-
-/**
- * Compute perceptual hash from image buffer using imghash.
- * Returns a hexadecimal string representation of the hash.
- * Returns null if hashing fails (e.g., invalid image data).
- */
-export async function computeImagePhash(
-  buffer: Buffer,
-): Promise<string | null> {
-  try {
-    // Dynamic import — imghash is ESM with a default export containing { hash, hashRaw, ... }
-    const imghashModule: {
-      default?: { hash?: (buf: Buffer) => Promise<string> };
-    } = await import("imghash");
-    const hashFn = imghashModule.default?.hash;
-    if (typeof hashFn !== "function") return null;
-    const hash = await hashFn(buffer);
-    return hash;
-  } catch {
-    return null;
-  }
-}
-
 // ---------------------------------------------------------------------------
 // Corrected Moderation (false-positive) helpers for dynamic few-shot injection
 // ---------------------------------------------------------------------------

services/discord-gateway/src/modules/ai-moderation/visionAnalyzer.ts

@@ -16,17 +16,14 @@ import type {
 import { llmVision } from "./llmClient.js";
 import {
   acquireMediaAnalysisLock,
-  computeImagePhash,
   deleteCachedMediaAnalysis,
   FAILED_ANALYSIS_PREFIX,
   getCachedMediaAnalysis,
-  getCachedMediaByPhash,
   inFlightVisionCalls,
   makeCustomEmojiCacheKey,
   makeImageCacheKey,
   makeStickerCacheKey,
   upsertCachedMediaAnalysis,
-  upsertCachedMediaByPhash,
   visionLruCache,
 } from "./mediaCache.js";
 
@@ -66,7 +63,6 @@ import {
 } from "./mediaDownloader.js";
 import {
   buildReferenceXml,
-  buildUserHistoryXml,
   buildUserProfileRef,
   escapeXml,
   formatReputationAttrs,
@@ -87,12 +83,10 @@ import {
   formatSearchResults,
   searchSearxng,
 } from "./searxngSearch.js";
+import { buildTermGlossaryBlock } from "./termGlossary.js";
 import { extractUrlsFromText } from "./urlFetcher.js";
 import { getUserProfile } from "./userProfileStore.js";
-import {
-  getUserRecentInfractions,
-  initializeUserReputation,
-} from "./userReputationStore.js";
+import { initializeUserReputation } from "./userReputationStore.js";
 
 // ---------------------------------------------------------------------------
 // Types
@@ -162,7 +156,10 @@ export const analyzeSingleMediaImage = async (
   const cached = await getCachedMediaAnalysis(cacheKey);
   if (cached && !isNoImageSeenText(cached)) {
     visionLruCache.set(cacheKey, cached);
-    log.debug({ cacheKey }, "Media analysis cache HIT (DB → LRU)");
+    log.debug(
+      { cacheKey, messageId, cachedLen: cached.length },
+      "Media analysis cache HIT (DB → LRU)",
+    );
     return `[Media analysis for message ${messageId}] ${image.sourceLabel}: ${cached}`;
   }
   if (cached) {
@@ -206,45 +203,19 @@ export const analyzeSingleMediaImage = async (
       return FAILED_ANALYSIS_PREFIX;
     }
 
-    // phash check
-    let phash: string | null = null;
-    if (image.image_url.url.startsWith("data:")) {
-      try {
-        const base64Data = image.image_url.url.split(",")[1];
-        if (base64Data) {
-          const imgBuffer = Buffer.from(base64Data, "base64");
-          phash = await computeImagePhash(imgBuffer);
-          if (phash) {
-            const phashCached = await getCachedMediaByPhash(phash);
-            if (phashCached && !isNoImageSeenText(phashCached)) {
-              visionLruCache.set(cacheKey, phashCached);
-              await upsertCachedMediaAnalysis(
-                cacheKey,
-                phashCached,
-                "vision_llm",
-                Date.now() + 24 * 60 * 60 * 1000,
-              ).catch(() => {});
-              return phashCached;
-            }
-            if (phashCached) {
-              log.warn(
-                { phash, cacheKey },
-                "phash cache HIT was no-image-seen — ignoring",
-              );
-            }
-          }
-        }
-      } catch {
-        phash = null;
-      }
-    }
-
     // Vision API call
     let lastError: Error | null = null;
     for (let attempt = 0; attempt < 3; attempt++) {
       try {
         const content = await llmVision(promptText, image.image_url);
         if (content && !isNoImageSeenText(content)) {
+          // Defensive: log when a vision analysis is cached so we can trace
+          // if the SAME analysis text is being stored for DIFFERENT cache keys
+          // (which would indicate the vision model is returning duplicates).
+          log.debug(
+            { cacheKey, messageId, contentLen: content.length },
+            "Vision analysis cached (new entry)",
+          );
           await upsertCachedMediaAnalysis(
             cacheKey,
             content,
@@ -252,20 +223,11 @@ export const analyzeSingleMediaImage = async (
             Date.now() + 24 * 60 * 60 * 1000,
           );
           visionLruCache.set(cacheKey, content);
-          if (phash) {
-            upsertCachedMediaByPhash(
-              phash,
-              content,
-              "vision_llm",
-              Date.now() + 7 * 24 * 60 * 60 * 1000,
-            ).catch(() => {});
-          }
           return content;
         }
         if (content) {
           // Model claims it saw no image — same as a null response: NOT a
-          // valid analysis, and caching it would poison the key for every
-          // re-analysis of the same image (phash TTL is 7 days).
+          // valid analysis, and caching it would poison the cache key.
           log.warn(
             { messageId, cacheKey },
             "Vision returned no-image-seen text — not caching",
@@ -413,6 +375,12 @@ export async function prepareMediaMessage(
       searxngXml = `\n<web_searches>\n${parts.join("\n")}\n</web_searches>`;
   }
 
+  // Term glossary — cached per-word Wikipedia definitions for words the LLM
+  // may not know. Bounded and cached (in-memory + Redis), so this adds no
+  // meaningful latency to the media path either.
+  const glossaryXml = await buildTermGlossaryBlock([content]).catch(() => "");
+  const glossaryCtx = glossaryXml ? `\n${glossaryXml}` : "";
+
   // Build XML block
   const webTexts = webTextMap.get(targetId) ?? [];
   const mediaAnalyses = mediaAnalysisMap.get(targetId) ?? [];
@@ -442,30 +410,12 @@ export async function prepareMediaMessage(
     ? buildUserProfileRef(target.user_id)
     : "";
 
-  // Rich reputation — same shape as the text path: attrs + optional
-  // <user_history> with the last flagged messages for repeat offenders.
+  // Rich reputation — attrs only, no user history injection (per channel context preference)
   const repAttrs = formatReputationAttrs(rep);
-  let repXml = `<user_reputation ${repAttrs}/>`;
-  if (rep.total_infractions > 0) {
-    try {
-      const history = await getUserRecentInfractions(target.user_id, 2);
-      const historyXml = buildUserHistoryXml(
-        history.map((h) => ({
-          content: h.content ?? "",
-          severity: h.severity,
-          created_at: h.created_at,
-        })),
-      );
-      if (historyXml) {
-        repXml = `<user_reputation ${repAttrs}>\n${historyXml}\n</user_reputation>`;
-      }
-    } catch {
-      // history is a bonus — fall back to attrs-only reputation
-    }
-  }
+  const repXml = `<user_reputation ${repAttrs}/>`;
 
   const isBot = resolveIsBot(target);
   const isEdited = resolveIsEdited(target);
-  const messageBlock = `<message id="${escapeXml(target.id)}" user="${escapeXml(resolveDisplayName(target))}" time="${new Date(target.created_at).toISOString()}"${isBot ? ` bot="true"` : ""}${isEdited ? ` edited="true"` : ""}>\n  ${repXml}${profileRef ? `\n  ${profileRef}` : ""}${refXml ? `\n  ${refXml}` : ""}\n  <content>${escapeXml(truncateForAi(content))}</content>${mediaContext ? ` ${escapeXml(mediaContext)}` : ""}${webContext}${mediaAnalysisContext}${searxngXml}\n</message>`;
+  const messageBlock = `<message id="${escapeXml(target.id)}" user="${escapeXml(resolveDisplayName(target))}" time="${new Date(target.created_at).toISOString()}"${isBot ? ` bot="true"` : ""}${isEdited ? ` edited="true"` : ""}>\n  ${repXml}${profileRef ? `\n  ${profileRef}` : ""}${refXml ? `\n  ${refXml}` : ""}\n  <content>${escapeXml(truncateForAi(content))}</content>${mediaContext ? ` ${escapeXml(mediaContext)}` : ""}${webContext}${mediaAnalysisContext}${searxngXml}${glossaryCtx}\n</message>`;
   return { targetId, messageBlock };
 }

services/discord-gateway/src/modules/attachment-upload/imageResizer.ts

@@ -4,10 +4,17 @@ import { createChildLogger } from "@/shared/logger/index";
 const log = createChildLogger("imageResizer");
 
 /**
- * Prepare an image buffer for optimal vision LLM analysis.
+ * Prepare an image buffer for vision LLM analysis.
  *
- * - Resizes to maxDim x maxDim maintaining aspect ratio (only if larger)
- * - Converts to PNG (lossless) to preserve full image detail
+ * - Resizes to maxDim x maxDim maintaining aspect ratio WITHOUT upscaling
+ *   (small images such as stickers/emojis are passed through at original size,
+ *   just re-encoded)
+ * - Encodes as JPEG (lossy, quality ~85). Photos compress VERY poorly in
+ *   lossless PNG — a 1024px Facebook photo balloons to multi-MB PNG base64 that
+ *   the vision model silently rejects (empty response → "Vision API null").
+ *   JPEG keeps the same photo at ~100–400KB, which the model processes fine and
+ *   stays well below request/token size limits.
+
  * - Falls back to original buffer if sharp fails
  *
  * @param buf - Raw image buffer
@@ -20,22 +27,17 @@ export async function resizeImageForVision(
 ): Promise<{ data: Buffer; mimeType: string }> {
   try {
     const metadata = await sharp(buf).metadata();
-    const inputFormat = metadata.format ?? "jpeg";
 
-    // Skip resize entirely if already within max dimension
-    if ((metadata.width ?? 0) <= maxDim && (metadata.height ?? 0) <= maxDim) {
-      return { data: buf, mimeType: `image/${inputFormat}` };
-    }
-
-    // Resize dimension only — convert to PNG lossless to preserve detail
+    // Always (re-)encode to JPEG and fit inside maxDim without upscaling.
+    // Skipping the encode for already-small images left raw originals in
+    // their native (often lossless PNG or full-quality) form, which could
+    // still bloat data URLs and trip the vision model's size limit.
     const resized = await sharp(buf)
-      .resize(maxDim, maxDim, {
-        fit: "inside",
-        withoutEnlargement: true,
-      })
-      .png()
+      .resize(maxDim, maxDim, { fit: "inside", withoutEnlargement: true })
+      .jpeg({ quality: 85 })
       .toBuffer();
 
+    const inputFormat = metadata.format ?? "jpeg";
     log.debug(
       {
         originalSize: buf.length,
@@ -45,10 +47,10 @@ export async function resizeImageForVision(
           ((buf.length - resized.length) / buf.length) * 100,
         ),
       },
-      "Image resized for vision analysis (lossless PNG)",
+      "Image resized for vision analysis (JPEG)",
     );
 
-    return { data: resized, mimeType: "image/png" };
+    return { data: resized, mimeType: "image/jpeg" };
   } catch (error) {
     log.warn(
       { error: error instanceof Error ? error.message : String(error) },

services/discord-gateway/src/modules/command-handler/commandHandler.ts

@@ -83,12 +83,7 @@ export class CommandHandler {
 
     // Create domain-specific handlers with their dependencies
     this.voiceHandler = new VoiceHandler(client, voiceController);
-    this.mediaHandler = new MediaHandler(client, () =>
-      voiceController.getStatus(),
-    );
-    // Give media handler access to disconnect/reconnect voice around screen
-    // share (GoLive needs its own WebRTC connection).
-    this.mediaHandler.setVoiceController(() => voiceController);
+    this.mediaHandler = new MediaHandler();
     this.guildHandler = new GuildHandler(client);
     this.moderationHandler = new ModerationHandler(client);
 

services/discord-gateway/src/modules/command-handler/media.handler.ts

@@ -1,6 +1,5 @@
 import { randomUUID } from "node:crypto";
 import { StreamType } from "@discordjs/voice";
-import type { Client } from "discord.js-selfbot-v13";
 import type { CommandMessage, CommandReply } from "../../shared/index.js";
 import { createChildLogger } from "../../shared/logger/index.js";
 import {
@@ -13,10 +12,6 @@ import type {
   MediaQueueItem,
 } from "../voice-recording/mediaTypes.js";
 import { discordPlayer } from "../voice-recording/player.js";
-import {
-  ScreenShareController,
-  type ScreenShareVoiceStatus,
-} from "../voice-recording/screenShareController.js";
 import { setMediaStatusKey } from "./mediaStatusSink.js";
 
 // ---------------------------------------------------------------------------
@@ -84,17 +79,8 @@ function buildStatusPayload(): MediaStatusPayload {
 
 export class MediaHandler {
   private logger = createChildLogger("media-handler");
-  private screenController: ScreenShareController | null = null;
-  private screenPlayback: { stop(): void } | null = null;
 
-  constructor(
-    private readonly client: Client | null = null,
-    private readonly getVoiceStatus: () => ScreenShareVoiceStatus = () => ({
-      connected: false,
-      activeGuildId: null,
-      activeChannelId: null,
-    }),
-  ) {
+  constructor() {
     // Register auto-advance on natural track end. advanceQueue mutates the
     // module-level currentTrackItem/queue, so we must re-publish the status
     // key afterward: otherwise the backend's Redis `media:status` cache (and
@@ -108,31 +94,11 @@ export class MediaHandler {
     });
   }
 
-  /**
-   * Give MediaHandler access to the VoiceController so screen-share can
-   * disconnect/reconnect the @discordjs audio connection around a GoLive
-   * stream (Discord allows only one voice session per user).
-   */
-  private voiceControllerAccessor:
-    | (() => {
-        disconnectGuild(guildId: string): Promise<void>;
-        connect(guildId: string, channelId: string): Promise<unknown>;
-        getStatus(): {
-          activeGuildId: string | null;
-          activeChannelId: string | null;
-        };
-      })
-    | null = null;
-
-  setVoiceController(accessor: typeof this.voiceControllerAccessor): void {
-    this.voiceControllerAccessor = accessor;
-  }
-
   /**
    * Persist the latest media state to Redis so the backend/frontend see queue
-   * advances that happen outside a command (natural track end, screen-share
-   * done). CommandHandler owns the Redis status-key writes for command-triggered
-   * changes; this covers the side-effect-only path.
+   * advances that happen outside a command (natural track end). CommandHandler
+   * owns the Redis status-key writes for command-triggered changes; this
+   * covers the side-effect-only path.
    */
   private publishStatus(): void {
     try {
@@ -152,7 +118,6 @@ export class MediaHandler {
   async handleMediaQueue(cmd: CommandMessage): Promise<CommandReply<unknown>> {
     // Accept both `url` (canonical) and `source` (legacy FE) for resilience.
     const url = String(cmd.payload.url ?? cmd.payload.source ?? "").trim();
-    const mode: MediaMode = cmd.payload.mode === "screen" ? "screen" : "music";
     const requestedBy = String(cmd.payload.requestedBy ?? "unknown");
 
     if (!url) {
@@ -175,74 +140,6 @@ export class MediaHandler {
       };
     }
 
-    // Screen share (GoLive) path — bypasses the audio queue entirely.
-    if (mode === "screen") {
-      try {
-        if (!this.client) {
-          return {
-            id: cmd.id,
-            success: false,
-            data: null,
-            error: "Gateway client not initialized",
-          };
-        }
-        if (!this.screenController) {
-          this.screenController = new ScreenShareController(
-            this.client,
-            this.getVoiceStatus,
-            // releaseVoice — disconnect the @discordjs/voice connection so the
-            // dank074 Streamer can take over (Discord: one voice session/user).
-            async (status) => {
-              const vc = this.voiceControllerAccessor?.();
-              const guildId = status.activeGuildId ?? null;
-              if (vc && guildId) {
-                await vc.disconnectGuild(guildId);
-              }
-            },
-            // restoreVoice — reconnect the @discordjs audio connection after
-            // the stream ends so mic/listen keep working.
-            async (status) => {
-              const vc = this.voiceControllerAccessor?.();
-              if (vc && status.activeGuildId && status.activeChannelId) {
-                await vc.connect(status.activeGuildId, status.activeChannelId);
-              }
-            },
-          );
-        }
-        const playback = await this.screenController.start(url);
-        this.screenPlayback = playback;
-        currentTrackItem = {
-          id: randomUUID(),
-          source: url,
-          title: url,
-          kind: "url",
-          mode: "screen",
-          requestedBy,
-          addedAt: Date.now(),
-          status: "playing",
-        };
-        playback.done
-          .catch((err) => {
-            this.logger.error(
-              { error: err instanceof Error ? err.message : String(err) },
-              "Screen playback promise rejected",
-            );
-          })
-          .finally(() => {
-            this.screenPlayback = null;
-            if (currentTrackItem?.mode === "screen") {
-              currentTrackItem = null;
-            }
-          });
-        this.logger.info({ url }, "Screen share started");
-        return { id: cmd.id, success: true, data: buildStatusPayload() };
-      } catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        this.logger.error({ error: message }, "Screen share failed to start");
-        return { id: cmd.id, success: false, data: null, error: message };
-      }
-    }
-
     // Lightweight metadata fetch for display — the full resolve happens in playNext
     let title: string = url;
     let duration: number | undefined;
@@ -264,7 +161,7 @@ export class MediaHandler {
       source: url,
       title,
       kind: "url" as const,
-      mode,
+      mode: "music",
       requestedBy,
       addedAt: Date.now(),
       status: "queued",
@@ -308,12 +205,6 @@ export class MediaHandler {
   }
 
   async handleMediaStop(cmd: CommandMessage): Promise<CommandReply<unknown>> {
-    // Stop screen share if active — playback.done.finally clears the item.
-    this.screenPlayback?.stop();
-    this.screenPlayback = null;
-    if (currentTrackItem?.mode === "screen") {
-      currentTrackItem = null;
-    }
     discordPlayer.stop("music");
     currentTrackItem = null;
     mediaQueue.length = 0; // Clear entire queue
@@ -394,7 +285,7 @@ export class MediaHandler {
       // Music playback: transcode once to high-quality OggOpus (48kHz stereo,
       // 192kbps) with volume baked into the encode. This avoids the double
       // lossy encode that inlineVolume would cause and gives Discord the
-      // cleanest possible stream. Screen share bypasses this entirely.
+      // cleanest possible stream.
       const transcoded = transcodeToHighQualityOgg(
         resolution.stream,
         discordPlayer.getMusicVolume(),

services/discord-gateway/src/modules/message-capture/messageCapture.ts

@@ -35,6 +35,13 @@ export interface MessageLocationInput {
 }
 
 const EXCLUDED_CHANNEL_IDS = new Set(config.EXCLUDED_CHANNEL_IDS);
+const BOT_EXCLUDED_CHANNEL_IDS = new Set(config.BOT_EXCLUDED_CHANNEL_IDS);
+
+function isBotExcludedChannel(message: Message): boolean {
+  if (!message.author?.bot) return false;
+  const id = getParentChannelId(message) ?? message.channelId;
+  return id != null && BOT_EXCLUDED_CHANNEL_IDS.has(id);
+}
 const EXCLUDED_THREAD_IDS = new Set(config.EXCLUDED_THREAD_IDS);
 
 function isExcludedThread(message: {
@@ -274,7 +281,7 @@ export function registerMessageCapture(client: Client): void {
 
   client.on("messageCreate", async (message) => {
     if (!shouldCaptureForAnyTarget(message, targets)) return;
-    if (message.author?.bot) return;
+    if (isBotExcludedChannel(message)) return;
     if (isAgeRestrictedMessage(message)) return;
     if (isExcludedThread(message)) return;
 
@@ -293,7 +300,7 @@ export function registerMessageCapture(client: Client): void {
 
   client.on("messageUpdate", async (_oldMessage, newMessage) => {
     if (!shouldCaptureForAnyTarget(newMessage, targets)) return;
-    if (newMessage.author?.bot) return;
+    if (isBotExcludedChannel(newMessage as Message)) return;
     if (isAgeRestrictedMessage(newMessage as Message)) return;
     if (isExcludedThread(newMessage)) return;
 

services/discord-gateway/src/modules/message-capture/messageMetadata.ts

@@ -515,7 +515,7 @@ export function renderDiscordMentions(
   content: string,
   metadata: string | null | undefined,
 ): string {
-  if (!content || !content.includes("<")) return content;
+  if (!content?.includes("<")) return content;
   const parsed = parseRichMessageMetadata(metadata);
   const roleName = new Map(
     (parsed?.mentionedRoles ?? []).map((r) => [r.id, r.name] as const),

services/discord-gateway/src/modules/message-capture/messagesAnalysis.ts

@@ -26,6 +26,8 @@ export interface AIAnalysisUpdate {
   confidence?: number | null;
   recommendedAction?: MessageRecord["ai_recommended_action"] | null;
   analyzedAt?: number | null;
+  /** Wall-clock time the AI analysis (LLM call) took, in milliseconds. */
+  analysisDurationMs?: number | null;
   error?: string | null;
 }
 
@@ -42,6 +44,7 @@ function buildAIAnalysisSet(result: AIAnalysisUpdate, now?: number) {
     ai_confidence: result.confidence ?? result.score ?? null,
     ai_recommended_action: result.recommendedAction ?? null,
     ai_analyzed_at: result.analyzedAt ?? now ?? Date.now(),
+    ai_analysis_duration_ms: result.analysisDurationMs ?? null,
     ai_error: result.error ?? null,
   };
 }

services/discord-gateway/src/modules/message-capture/moderationActionsDb.ts

@@ -1,4 +1,4 @@
-import { and, desc, eq, inArray, type SQL, sql } from "drizzle-orm";
+import { and, desc, eq, inArray, type SQL } from "drizzle-orm";
 import type { NodePgDatabase } from "drizzle-orm/node-postgres";
 import type * as schema from "../../shared/database/schema.js";
 import { moderationActionsTable } from "../../shared/database/schema.js";

services/discord-gateway/src/modules/message-capture/retentionDb.ts

@@ -1,4 +1,4 @@
-import { and, eq, isNull, or } from "drizzle-orm";
+import { and, eq, isNull } from "drizzle-orm";
 import type { NodePgDatabase } from "drizzle-orm/node-postgres";
 import { createChildLogger, type Logger } from "@/shared/logger/index";
 import type * as schema from "../../shared/database/schema.js";

services/discord-gateway/src/modules/message-capture/reviewsDb.ts

@@ -1,4 +1,4 @@
-import { and, desc, eq, inArray, type SQL, sql } from "drizzle-orm";
+import { and, desc, eq, inArray, type SQL } from "drizzle-orm";
 import type { NodePgDatabase } from "drizzle-orm/node-postgres";
 import type * as schema from "../../shared/database/schema.js";
 import { messageReviewsTable } from "../../shared/database/schema.js";

services/discord-gateway/src/modules/voice-recording/mediaSource.ts

@@ -1,4 +1,7 @@
 import { type ChildProcess, spawn } from "node:child_process";
+import { chmodSync, existsSync, readFileSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 import { PassThrough, type Readable } from "node:stream";
 import { StreamType } from "@discordjs/voice";
 import { createChildLogger } from "@/shared/logger/index";
@@ -214,6 +217,85 @@ function buildNotInstalledError(): Error {
   );
 }
 
+/**
+ * Build the yt-dlp --cookies args. YouTube blocks anonymous embeds with a
+ * "Sign in to confirm you're not a bot" 403 unless yt-dlp is given a logged-
+ * in account's cookies. The path is configurable via GMW_YT_COOKIES_PATH
+ * (default: the BWS-provided file the deploy writes to /etc/.../ytcookies.txt).
+ * If the file doesn't exist we pass nothing and fall back to anon (YouTube
+ * may 403 — playback will fail gracefully, not crash).
+ */
+var _cachedCookiePath: string | null = null;
+function buildCookieArgs(): string[] {
+  // Single source of truth: BWS injects the account cookies via env
+  // (gmw_yt_downloader_cookies → GMW_YT_DOWNLOADER_COOKIES by bws-exec).
+  // We materialize them to a temp Netscape file because yt-dlp --cookies
+  // only accepts a file path, not stdin, and multiline env values are not
+  // reliable to pass directly on the spawn argv. Falls back to the on-disk
+  // file at GMW_YT_COOKIES_PATH (or /etc/gmw-discord-gateway/ytcookies.txt)
+  // which the Nix deploy writes from BWS once at start.
+  if (_cachedCookiePath) return ["--cookies", _cachedCookiePath];
+  const envCookies = process.env.GMW_YT_DOWNLOADER_COOKIES?.trim();
+  if (envCookies?.includes("LOGIN_INFO")) {
+    const fdPath = join(tmpdir(), `gmw-ytcookies.${process.pid}.txt`);
+    writeFileSync(fdPath, envCookies);
+    try {
+      chmodSync(fdPath, 0o600);
+    } catch {
+      /* best-effort */
+    }
+    _cachedCookiePath = fdPath;
+    logger.info(
+      { cookiePath: fdPath, source: "GMW_YT_DOWNLOADER_COOKIES env" },
+      "Using YouTube cookies (from BWS env)",
+    );
+    return ["--cookies", fdPath];
+  }
+  const cookiePath =
+    process.env.GMW_YT_COOKIES_PATH ?? "/etc/gmw-discord-gateway/ytcookies.txt";
+  try {
+    if (cookiePath && existsSync(cookiePath)) {
+      // Never hand the ORIGINAL system file to yt-dlp: recent yt-dlp rewrites
+      // the cookie file on close (`--cookies` implies write-back). The system
+      // file is owned by another user (root/deploy) and the service user
+      // cannot write it → PermissionError → yt-dlp exits 1 → playback
+      // fails for every attempt. Copy to a per-run temp file (like the env
+      // branch above) so write-back lands somewhere we own; if the original
+      // is not readable we fall back to anonymous (YouTube may 403 → the
+      // screen-share controller retries via Invidious mirrors without auth).
+      let cookieContents: string;
+      try {
+        cookieContents = readFileSync(cookiePath, "utf8");
+      } catch {
+        logger.warn(
+          { cookiePath },
+          "Cookie file not readable; continuing without cookies (anon)",
+        );
+        return [];
+      }
+      const fdPath = join(tmpdir(), `gmw-ytcookies.${process.pid}.txt`);
+      writeFileSync(fdPath, cookieContents);
+      try {
+        chmodSync(fdPath, 0o600);
+      } catch {
+        /* best-effort */
+      }
+      _cachedCookiePath = fdPath;
+      logger.info(
+        { cookiePath: fdPath, source: "on-disk file (copied)" },
+        "Using YouTube cookies for yt-dlp",
+      );
+      return ["--cookies", fdPath];
+    }
+  } catch {
+    /* ignore — fallback to anon */
+  }
+  logger.warn(
+    "No YouTube cookies available; yt-dlp will use anonymous (YouTube may 403)",
+  );
+  return [];
+}
+
 // ---------------------------------------------------------------------------
 // Public API
 // ---------------------------------------------------------------------------
@@ -238,6 +320,7 @@ export function resolveMediaUrl(
 ): Promise<MediaSourceResolution> {
   return new Promise<MediaSourceResolution>((resolve, reject) => {
     const format = options?.quality ?? "bestaudio";
+    const cookieArgs = buildCookieArgs();
     const args = [
       "-f",
       format,
@@ -245,6 +328,7 @@ export function resolveMediaUrl(
       "-",
       "--no-progress",
       "--no-warnings",
+      ...cookieArgs,
       "--print",
       "before_dl:title",
       "--print",
@@ -374,245 +458,6 @@ export function resolveMediaUrl(
   });
 }
 
-/**
- * Resolve a media URL to a single playable input stream for screen share /
- * GoLive streaming.
- *
- * yt-dlp `--get-url` with `bestvideo+bestaudio` prints the video-only and
- * audio-only URLs on SEPARATE lines. The old code took only the first line
- * (video-only) → ffmpeg had no audio track → GoLive stream had no sound.
- *
- * This returns a single input that `prepareStream` (which accepts only ONE
- * ffmpeg input) can consume while STILL including audio:
- *  - If yt-dlp offers a merged progressive URL (one URL, video+audio) it is
- *    returned directly.
- *  - Otherwise the video-only + audio-only DASH URLs are fetched in the SAME
- *    yt-dlp run (signature URLs expire quickly) and merged locally by an
- *    ffmpeg process into a single NUT stream, which is streamed to the
- *    consumer over a Readable. NUT over stdin auto-probes cleanly (verified:
- *    av1+opus merge → H264+opus transcode).
- *
- * @returns a direct video URL (string) or a Readable of the merged NUT stream.
- */
-export function getDirectScreenInput(url: string): Promise<string | Readable> {
-  return new Promise<string | Readable>((resolve, reject) => {
-    const args = [
-      url,
-      "--dump-single-json",
-      "--format",
-      "bestvideo[protocol^=http]+bestaudio[protocol^=http]/best[protocol^=http]/best",
-      "--no-playlist",
-      "--no-warnings",
-      "--quiet",
-      // NOTE: deliberately NOT --no-simulate. Simulate mode still resolves the
-      // requested format URLs into the JSON (requested_formats[].url), and it
-      // avoids yt-dlp writing .part files into the process CWD — which is the
-      // read-only Nix store dir for the deployed gateway (EACCES).
-    ];
-
-    logger.info({ url }, "Spawning yt-dlp for screen share input resolution");
-
-    const proc = spawn("yt-dlp", args, {
-      stdio: ["pipe", "pipe", "pipe"],
-    });
-
-    activeProcesses.add(proc);
-
-    let stdoutBuf = "";
-    let stderrBuf = "";
-    const MAX_STDERR = 4096;
-    const MAX_STDOUT = 8 * 1024 * 1024; // JSON metadata + requested format URLs
-
-    if (proc.stdout) {
-      proc.stdout.on("data", (chunk: Buffer) => {
-        if (stdoutBuf.length < MAX_STDOUT) {
-          stdoutBuf += chunk
-            .toString("utf8")
-            .slice(0, MAX_STDOUT - stdoutBuf.length);
-        }
-      });
-    }
-
-    if (proc.stderr) {
-      proc.stderr.on("data", (chunk: Buffer) => {
-        if (stderrBuf.length < MAX_STDERR) {
-          stderrBuf += chunk
-            .toString("utf8")
-            .slice(0, MAX_STDERR - stderrBuf.length);
-        }
-      });
-    }
-
-    proc.on("error", (err: NodeJS.ErrnoException) => {
-      activeProcesses.delete(proc);
-      if (err.code === "ENOENT") {
-        reject(buildNotInstalledError());
-      } else {
-        reject(new Error(`yt-dlp failed to start: ${err.message}`));
-      }
-    });
-
-    proc.on("close", (code) => {
-      activeProcesses.delete(proc);
-
-      if (code !== 0) {
-        const detail = stderrBuf.trim() ? `: ${stderrBuf.trim()}` : "";
-        reject(
-          new Error(
-            `yt-dlp screen input resolution exited with code ${code}${detail}`,
-          ),
-        );
-        return;
-      }
-
-      let parsed: Record<string, unknown>;
-      try {
-        parsed = JSON.parse(stdoutBuf.trim()) as Record<string, unknown>;
-      } catch (parseErr) {
-        reject(
-          new Error(
-            `Failed to parse yt-dlp JSON for screen input: ${(parseErr as Error).message}`,
-          ),
-        );
-        return;
-      }
-
-      resolveScreenInput(parsed).then(resolve, (err: unknown) => {
-        const message = err instanceof Error ? err.message : String(err);
-        reject(
-          new Error(`Failed to build screen input for "${url}": ${message}`),
-        );
-      });
-    });
-  });
-}
-
-/**
- * From a parsed yt-dlp JSON info dict, decide how to feed a single ffmpeg
- * input with both video and audio.
- */
-async function resolveScreenInput(
-  info: Record<string, unknown>,
-): Promise<string | Readable> {
-  const requested = info.requested_formats as
-    | Array<Record<string, unknown>>
-    | undefined;
-
-  // Merged/progressive single URL (video+audio in one). Common when yt-dlp
-  // selects a single format (e.g. format 18 progressive mp4) or when a direct
-  // muxed URL is available.
-  const singleUrl = info.url as string | undefined;
-  const singleHasAudio =
-    info.acodec !== "none" &&
-    typeof info.acodec === "string" &&
-    info.acodec.length > 0;
-
-  if (typeof singleUrl === "string" && singleUrl && singleHasAudio) {
-    logger.debug("Screen share uses merged progressive single URL");
-    return singleUrl;
-  }
-
-  // Separate video-only + audio-only DASH formats → merge locally via ffmpeg.
-  if (Array.isArray(requested) && requested.length >= 2) {
-    const video = requested.find(
-      (rf) => rf.vcodec && String(rf.vcodec) !== "none",
-    );
-    const audio = requested.find(
-      (rf) => rf.acodec && String(rf.acodec) !== "none",
-    );
-    const videoUrl = video?.url as string | undefined;
-    const audioUrl = audio?.url as string | undefined;
-
-    if (
-      typeof videoUrl === "string" &&
-      videoUrl.length > 0 &&
-      typeof audioUrl === "string" &&
-      audioUrl.length > 0
-    ) {
-      return mergeScreenStreams(videoUrl, audioUrl);
-    }
-  }
-
-  throw new Error(
-    "yt-dlp returned neither a merged progressive URL nor a video+audio format pair",
-  );
-}
-
-/**
- * Merge a video-only URL and an audio-only URL into a single NUT stream using
- * a child ffmpeg process. Both URLs come from the same yt-dlp run, so they
- * share the same signature/expiry and are consumed immediately.
- */
-function mergeScreenStreams(videoUrl: string, audioUrl: string): Readable {
-  logger.info("Merging video+audio DASH streams into a single NUT input");
-
-  const ffmpeg = spawn(
-    "ffmpeg",
-    [
-      "-hide_banner",
-      "-loglevel",
-      "error",
-      "-reconnect",
-      "1",
-      "-reconnect_streamed",
-      "1",
-      "-reconnect_delay_max",
-      "5",
-      "-i",
-      videoUrl,
-      "-i",
-      audioUrl,
-      "-map",
-      "0:v:0",
-      "-map",
-      "1:a:0",
-      "-c:v",
-      "copy",
-      "-c:a",
-      "copy",
-      "-f",
-      "nut",
-      "pipe:1",
-    ],
-    { stdio: ["ignore", "pipe", "pipe"] },
-  );
-
-  // Track so cleanup() can terminate the merge during graceful shutdown.
-  activeProcesses.add(ffmpeg);
-  ffmpeg.once("exit", () => {
-    activeProcesses.delete(ffmpeg);
-  });
-
-  // Prevent the ffmpeg stderr from filling the pipe buffer / leaking.
-  let stderrBuf = "";
-  const MAX_STDERR = 4096;
-  ffmpeg.stderr?.on("data", (chunk: Buffer) => {
-    if (stderrBuf.length < MAX_STDERR) {
-      stderrBuf += chunk.toString("utf8");
-    }
-  });
-
-  ffmpeg.on("error", (err) => {
-    const msg =
-      err.message === "spawn ffmpeg ENOENT"
-        ? "FFmpeg not found! Install ffmpeg in the container."
-        : err.message;
-    logger.error({ error: msg }, "Screen stream merge ffmpeg error");
-  });
-
-  ffmpeg.on("exit", (code) => {
-    const stderr = stderrBuf.trim();
-    logger.warn(
-      { code, stderr: stderr.slice(-500) || undefined },
-      "Screen stream merge ffmpeg exited",
-    );
-  });
-
-  const stream = ffmpeg.stdout;
-  stream.setMaxListeners(32);
-  return stream;
-}
-
 /**
  * Extract metadata (title, duration, thumbnail) from a media URL
  * without downloading the audio stream.

services/discord-gateway/src/modules/voice-recording/mediaTypes.ts

@@ -1,7 +1,7 @@
 import type { Readable } from "node:stream";
 import type { StreamType } from "@discordjs/voice";
 
-export type MediaMode = "music" | "screen";
+export type MediaMode = "music";
 export type MediaSourceKind =
   | "url"
   | "local"
@@ -51,23 +51,7 @@ export interface MusicPlayer {
   play(source: ResolvedMediaSource): MusicPlayback;
 }
 
-export interface ScreenSharePlayback {
-  done: Promise<void>;
-  stop(): void;
-}
-
-export interface ScreenShareVoiceStatus {
-  connected: boolean;
-  activeGuildId: string | null;
-  activeChannelId: string | null;
-}
-
-export interface ScreenShareController {
-  isActive(): boolean;
-  start(source: string): Promise<ScreenSharePlayback>;
-}
-
-export type DiscordPlayerOwner = "none" | "browser-bridge" | "music" | "screen";
+export type DiscordPlayerOwner = "none" | "browser-bridge" | "music";
 
 export interface DiscordPlayOptions {
   inputType?: StreamType;

services/discord-gateway/src/modules/voice-recording/screenShareController.ts

@@ -1,191 +0,0 @@
-import type { Client } from "discord.js-selfbot-v13";
-import { createChildLogger } from "@/shared/logger/index";
-import {
-  Encoders,
-  normalizeVideoCodec,
-  playStream,
-  prepareStream,
-  Streamer,
-} from "../../goLive/index.js";
-import { getDirectScreenInput } from "./mediaSource.js";
-import type { ScreenSharePlayback } from "./mediaTypes.js";
-import { discordPlayer } from "./player.js";
-
-const logger = createChildLogger("screen-share");
-
-export interface ScreenShareVoiceStatus {
-  connected: boolean;
-  activeGuildId: string | null;
-  activeChannelId: string | null;
-}
-
-/**
- * Discord Go Live (screenshare) via @dank074/discord-video-stream.
- *
- * Pipeline:
- *   URL (YouTube, dll.) → yt-dlp direct video URL → ffmpeg (H264 720p30) →
- *   playStream({ type: "go-live" }) → Discord voice channel as Go Live.
- *
- * Restored from the pre-microservices implementation (commit d50ce86,
- * src/media/screenShareController.ts) — the interface survived in
- * mediaTypes.ts but the implementation was lost during the split.
- */
-export class ScreenShareController {
-  private logger = createChildLogger("screen-share");
-  private streamer: Streamer | null = null;
-  private active: ScreenSharePlayback | null = null;
-
-  constructor(
-    private readonly client: Client,
-    private readonly getVoiceStatus: () => ScreenShareVoiceStatus,
-    /** Disconnect the @discordjs/voice connection so the Streamer can take
-     *  over the voice channel (Discord allows only ONE voice session per user
-     *  — two connections collide and the Streamer never gets VOICE_SERVER_UPDATE). */
-    private readonly releaseVoice: (
-      status: ScreenShareVoiceStatus,
-    ) => void | Promise<void>,
-    /** Reconnect the @discordjs/voice connection after the stream ends. */
-    private readonly restoreVoice: (
-      status: ScreenShareVoiceStatus,
-    ) => void | Promise<void>,
-  ) {}
-
-  isActive(): boolean {
-    return this.active !== null;
-  }
-
-  async start(source: string): Promise<ScreenSharePlayback> {
-    const status = this.getVoiceStatus();
-    if (!status.connected || !status.activeGuildId || !status.activeChannelId) {
-      throw new Error("Connect to a voice channel before sharing screen");
-    }
-
-    if (this.active || discordPlayer.getOwner() !== "none") {
-      throw new Error("Another media mode is active");
-    }
-
-    try {
-      const input = await getDirectScreenInput(source);
-      if (!this.streamer) {
-        this.streamer = new Streamer(this.client);
-      }
-
-      const guild = this.client.guilds.cache.get(status.activeGuildId);
-      const channel = guild?.channels.cache.get(status.activeChannelId);
-      if (
-        !channel ||
-        (channel.type !== "GUILD_VOICE" && channel.type !== "GUILD_STAGE_VOICE")
-      ) {
-        throw new Error(
-          `Voice channel ${status.activeChannelId} not found for screen share`,
-        );
-      }
-
-      // Free the @discordjs/voice connection BEFORE the Streamer joins, so
-      // the user has only one voice session (Discord requirement).
-      await this.releaseVoice(status);
-
-      await Promise.race([
-        this.streamer.joinVoiceChannel(channel),
-        new Promise<never>((_, reject) =>
-          setTimeout(
-            () =>
-              reject(
-                new Error("Timed out joining voice channel for screen share"),
-              ),
-            15000,
-          ),
-        ),
-      ]);
-
-      const prepared = prepareStream(input, {
-        encoder: Encoders.software({ x264: { preset: "superfast" } }),
-        width: 1280,
-        height: 720,
-        frameRate: 30,
-        bitrateVideo: 2500,
-        bitrateVideoMax: 4000,
-        includeAudio: true,
-        videoCodec: normalizeVideoCodec("H264"),
-      });
-      const { command } = prepared;
-
-      let stopped = false;
-      // Restore the @discordjs/voice connection after the stream ends (both
-      // natural end and failure), so the user can keep using audio/mic.
-      const restoreAfter = () => {
-        if (!stopped) {
-          stopped = true;
-          try {
-            command.kill("SIGTERM");
-          } catch {
-            /* already dead */
-          }
-        }
-        try {
-          this.streamer?.voiceConnection?.stop();
-        } catch {
-          /* already gone */
-        }
-        if (this.restoreVoice) {
-          // Best-effort restore after a short delay. Discord often needs the
-          // Streamer's session fully torn down before @discordjs/voice can
-          // re-join; if that races, the reconnect times out — the FE shows
-          // disconnected and the user just clicks Connect again. This is an
-          // accepted UX tradeoff for GoLive (single voice session per user).
-          setTimeout(() => {
-            Promise.resolve(this.restoreVoice(status)).catch((err) => {
-              this.logger.warn(
-                { error: err instanceof Error ? err.message : String(err) },
-                "Failed to restore voice connection after screen share (user can reconnect manually)",
-              );
-            });
-          }, 5000);
-        }
-      };
-      const done = playStream(prepared, this.streamer, {
-        type: "go-live",
-      })
-        .catch((err: unknown) => {
-          // Never let a stream failure become an unhandledRejection — that
-          // crashed the whole gateway. Log + surface via the done promise.
-          const message = err instanceof Error ? err.message : String(err);
-          this.logger.error(
-            { error: message, source },
-            "Screen stream failed during playback",
-          );
-        })
-        .finally(() => {
-          restoreAfter();
-          this.active = null;
-        });
-      this.active = {
-        done,
-        stop: () => {
-          if (stopped) return;
-          stopped = true;
-          try {
-            command.kill("SIGTERM");
-          } catch {
-            /* already dead */
-          }
-          // Leave the voice channel the Streamer joined (its own connection).
-          try {
-            this.streamer?.voiceConnection?.stop();
-          } catch {
-            /* already gone */
-          }
-          this.active = null;
-        },
-      };
-
-      logger.info({ source }, "Screen share started");
-      return this.active;
-    } catch (error) {
-      this.active = null;
-      const message = error instanceof Error ? error.message : String(error);
-      logger.error({ error: message, source }, "Screen stream failed");
-      throw error;
-    }
-  }
-}

services/discord-gateway/src/modules/voice-recording/transmitter.ts

@@ -27,8 +27,6 @@ export class VoiceTransmitter {
   private gate = Promise.resolve();
   /** Set true before sending SIGTERM so exit handler knows it's intentional */
   private _expectedExit = false;
-  /** True while the underlying stream is in a drain state (backpressure) */
-  private draining = false;
 
   /**
    * Start listening for PCM audio data from Redis and stream to Discord
@@ -179,15 +177,13 @@ export class VoiceTransmitter {
             const canContinue = stream.write(pcmBuffer);
             // Backpressure: queue until drain
             if (!canContinue) {
-              this.draining = true;
               stream.once("drain", () => {
-                this.draining = false;
-                // Re-acquire stream reference (could have been replaced by restart)
                 const currentStream = this.pcmStream;
                 if (!currentStream || !this.isActive) return;
                 // Flush queued chunks
                 while (this.backpressureQueue.length > 0) {
-                  const queued = this.backpressureQueue.shift()!;
+                  const queued = this.backpressureQueue.shift();
+                  if (!queued) break;
                   try {
                     if (!currentStream.write(queued)) break;
                   } catch (err) {
@@ -237,7 +233,6 @@ export class VoiceTransmitter {
       this.isActive = false;
 
       this.backpressureQueue = [];
-      this.draining = false;
 
       if (this.pcmStream) {
         this.pcmStream.removeAllListeners("drain");

services/discord-gateway/src/shared/config/index.ts

@@ -32,6 +32,13 @@ export const configSchema = z
       .default("")
       .transform((v) => v.split(",").filter(Boolean))
       .describe("Thread IDs to exclude from capture"),
+    BOT_EXCLUDED_CHANNEL_IDS: z
+      .string()
+      .default("1206269771340058694")
+      .transform((v) => v.split(",").filter(Boolean))
+      .describe(
+        "Channel IDs where bot messages are NOT captured/analyzed (bot detection stays on everywhere else)",
+      ),
 
     // ── Legacy voice ─────────────────────────────────────────────────────
     VOICE_GUILD_ID: z.string().min(1).optional(),
@@ -92,6 +99,10 @@ export const configSchema = z
 
     // ── Redis ────────────────────────────────────────────────────────────
     REDIS_URL: z.string().default("redis://localhost:6379"),
+    // ── SearXNG ───────────────────────────────────────────────────────────
+    // Instance for web search + term glossary lookups. Override when the
+    // default instance is down/rate-limited.
+    SEARXNG_BASE_URL: z.string().url().default("https://searxng.imrnes.team"),
     // ── Voice PCM WebSocket (direct gateway→backend, bypasses Redis) ────
     VOICE_PCM_WS_ENABLED: z
       .string()
@@ -133,7 +144,17 @@ export const configSchema = z
       .url()
       .default("https://9router.asepharyana.my.id/v1"),
     AI_LLM_MODEL: z.string().default("text"),
-    AI_LLM_VISION_MODEL: z.string().optional(),
+    // Vision uses the SAME router/base URL as text moderation
+    // (AI_LLM_BASE_URL) but a different model alias. The dedicated NVIDIA
+    // multimodal endpoint was removed.
+    AI_LLM_VISION_MODEL: z.string().default("multimodal"),
+    AI_LLM_DISABLE_THINKING: z
+      .string()
+      .default("true")
+      .transform((v) => v === "true")
+      .describe(
+        "Disable LLM chain-of-thought (reasoning/thinking) to speed up AI analysis. Set false to restore thinking.",
+      ),
     AI_LLM_EMBEDDING_MODEL: z.string().optional(),
     AI_LLM_EMBEDDING_MIN_SIMILARITY: z.coerce
       .number()
@@ -171,6 +192,24 @@ export const configSchema = z
       .int()
       .positive()
       .default(30000),
+    // Term glossary — per-word Wikipedia lookups (via SearXNG) for words the
+    // LLM may not know (slang, jargon, regional language, foreign terms).
+    // Definitions are cached (in-memory + Redis) so repeat lookups are fast.
+    // Disable to skip glossary lookups entirely and analyze without them.
+    AI_GLOSSARY_ENABLED: z
+      .string()
+      .optional()
+      .transform((v) => v === "true")
+      .default(true),
+    // Max glossary terms looked up per analysis batch (keeps latency bounded).
+    AI_GLOSSARY_MAX_TERMS: z.coerce.number().int().min(1).max(20).default(6),
+    // Min word length for a term to be considered glossary-worthy.
+    AI_GLOSSARY_MIN_WORD_LENGTH: z.coerce
+      .number()
+      .int()
+      .min(2)
+      .max(20)
+      .default(5),
 
     // ── AI Analysis Timing ──────────────────────────────────────────────
     AI_ANALYSIS_DEBOUNCE_MS: z.coerce.number().positive().default(500),

services/discord-gateway/src/shared/database/schema.ts

@@ -62,6 +62,9 @@ export const pgMessagesTable = pgTable(
       enum: ["none", "monitor", "warn", "review", "delete", "escalate"],
     }),
     ai_analyzed_at: pgBigint("ai_analyzed_at", { mode: "number" }),
+    ai_analysis_duration_ms: pgBigint("ai_analysis_duration_ms", {
+      mode: "number",
+    }),
     ai_error: pgText("ai_error"),
   },
   (table) => ({
@@ -435,6 +438,32 @@ export const pgStickerCacheTable = pgTable(
 
 export const stickerCacheTable = pgStickerCacheTable;
 
+/**
+ * Term Glossary Cache Table (PostgreSQL)
+ * Permanently stores resolved term definitions (Wikipedia/SearXNG lookups).
+ * Definitions rarely change, so once a term is successfully resolved it is
+ * persisted here forever — Redis/LRU only act as fast read caches in front.
+ * Terms with NO definition (misses) are NOT stored here; they stay ephemeral
+ * in Redis with a short TTL so transient lookup failures get retried.
+ */
+export const pgTermGlossaryCacheTable = pgTable(
+  "term_glossary_cache",
+  {
+    term: pgText("term").primaryKey(),
+    definition: pgText("definition").notNull(),
+    source_url: pgText("source_url").notNull().default(""),
+    resolved_at: pgBigint("resolved_at", { mode: "number" }).notNull(),
+    hit_count: pgInteger("hit_count").notNull().default(0),
+  },
+  (table) => ({
+    resolvedAtIdx: pgIndex("idx_term_glossary_cache_resolved_at").on(
+      table.resolved_at,
+    ),
+  }),
+);
+
+export const termGlossaryCacheTable = pgTermGlossaryCacheTable;
+
 // =============================================================================
 // Meta / System
 // =============================================================================
@@ -580,6 +609,11 @@ export type TextAnalysisCacheInsert =
 export type StickerCacheRecord = typeof stickerCacheTable.$inferSelect;
 export type StickerCacheInsert = typeof stickerCacheTable.$inferInsert;
 
+// Term Glossary Cache
+export type TermGlossaryCache = typeof termGlossaryCacheTable.$inferSelect;
+export type TermGlossaryCacheInsert =
+  typeof termGlossaryCacheTable.$inferInsert;
+
 // Muxer Jobs
 export type MuxerJob = typeof muxerJobsTable.$inferSelect;
 export type MuxerJobInsert = typeof muxerJobsTable.$inferInsert;

services/discord-gateway/src/shared/utils/index.ts

@@ -108,5 +108,8 @@ export async function retryWithBackoff<T>(
       });
     }
   }
-  throw lastError!;
+  // lastError is always set: the for-loop only exits via break when attempt
+  // === retries, which only happens in the catch branch that sets lastError.
+  if (!lastError) throw new Error("Unknown retry error");
+  throw lastError;
 }

services/discord-gateway/tests/goLive-port.test.ts

@@ -1,94 +0,0 @@
-/**
- * goLive port smoke tests — verify the TS layer (no native binding needed
- * for these; native is covered by the C++/node test-packetizer.js).
- */
-import { describe, expect, it } from "vitest";
-import { H264Helpers } from "../src/goLive/AnnexBHelper.js";
-import { AVCodecID } from "../src/goLive/Demuxer.js";
-import {
-  BaseMediaStream,
-  CodecPayloadType,
-  Encoders,
-  normalizeVideoCodec,
-} from "../src/goLive/index.js";
-import { rewriteSPSVUI } from "../src/goLive/SPSVUIRewriter.js";
-
-describe("goLive port: codec + encoders", () => {
-  it("normalizeVideoCodec maps aliases to canonical names", () => {
-    expect(normalizeVideoCodec("H.264")).toBe("H264");
-    expect(normalizeVideoCodec("AVC")).toBe("H264");
-    expect(normalizeVideoCodec("h265")).toBe("H265");
-    expect(normalizeVideoCodec("vp8")).toBe("VP8");
-    expect(normalizeVideoCodec("av1")).toBe("AV1");
-  });
-
-  it("software encoder exposes x264 libx264 superfast film", () => {
-    const enc = Encoders.software()();
-    expect(enc.H264.name).toBe("libx264");
-    expect(enc.H264.options).toContain("-preset superfast");
-    expect(enc.H264.options).toContain("-tune film");
-  });
-
-  it("CodecPayloadType has opus + H264 entries", () => {
-    expect(CodecPayloadType.opus).toBeDefined();
-    expect(CodecPayloadType.H264).toBeDefined();
-  });
-});
-
-describe("goLive port: annexb + sps rewriter", () => {
-  it("H264Helpers detects NAL unit types", () => {
-    const nal = Buffer.from([0x67, 0x42, 0x00, 0x1e]); // SPS
-    expect(H264Helpers.getUnitType(nal)).toBe(7); // SPS type
-    expect(H264Helpers.getUnitType(Buffer.from([0x65, 0x88]))).toBe(5); // IDR
-  });
-
-  it("rewriteSPSVUI returns a buffer for valid SPS", () => {
-    const sps = Buffer.from([
-      0x67, 0x42, 0x00, 0x1e, 0x96, 0x54, 0x05, 0x01, 0xec, 0x80,
-    ]);
-    expect(() => rewriteSPSVUI(sps)).not.toThrow();
-  });
-});
-
-describe("goLive port: streams", () => {
-  it("BaseMediaStream accepts plain frame objects", () => {
-    // BaseMediaStream is abstract — use a concrete subclass that no-ops the
-    // packetizer hook.
-    class TestStream extends BaseMediaStream {
-      async _sendFrame(_frame: Buffer, _frametime: number): Promise<void> {
-        /* no-op */
-      }
-    }
-    const stream = new TestStream("video");
-    const frame = {
-      data: Buffer.from([1, 2, 3]),
-      pts: 0,
-      duration: 40,
-      timeBase: { num: 1, den: 48000 },
-      flags: 0,
-      streamIndex: 0,
-      free: () => {},
-    };
-    expect(() => stream.write(frame)).not.toThrow();
-    stream.end();
-  });
-});
-
-describe("goLive port: demuxer codec ids", () => {
-  it("maps H264/HEVC/opus AVCodecID values", () => {
-    expect(AVCodecID.AV_CODEC_ID_H264).toBe(27);
-    expect(AVCodecID.AV_CODEC_ID_HEVC).toBe(173);
-    expect(AVCodecID.AV_CODEC_ID_OPUS).toBe(86019);
-  });
-});
-
-describe("goLive port: prepareStream option merge", () => {
-  it("merges default options into the descriptor (no ffmpeg spawn)", () => {
-    // Import the merge logic directly via the module; prepareStream spawns
-    // ffmpeg so we verify the descriptors it would build by checking the
-    // encoder + option functions that prepareStream uses.
-    const enc = Encoders.software()();
-    expect(enc.H264.options).toContain("-forced-idr 1");
-    expect(normalizeVideoCodec("H264")).toBe("H264");
-  });
-});

services/discord-gateway/tests/golive-demux-e2e.ts

@@ -1,40 +0,0 @@
-// Phase 2 E2E: Demuxer on a real ffmpeg-generated H264 file.
-// Run: npx tsx tests/golive-demux-e2e.ts
-
-import { createReadStream } from "node:fs";
-import { demux } from "../src/goLive/Demuxer.js";
-
-const input = process.argv[2] ?? "/tmp/sample.h264";
-const { video, close } = await demux(createReadStream(input), {
-  format: "h264",
-});
-
-console.log(
-  "video:",
-  JSON.stringify({
-    codecName: video.codecName,
-    width: video.width,
-    height: video.height,
-    duration: video.duration,
-    fps: Math.round(video.framerate_num / video.framerate_den),
-  }),
-);
-
-let count = 0;
-let keyframes = 0;
-let bytes = 0;
-video.stream.on("data", (frame: { data: Buffer; keyframe: boolean }) => {
-  count++;
-  bytes += frame.data.length;
-  if (frame.keyframe) keyframes++;
-});
-video.stream.on("end", () => {
-  console.log(`frames: ${count} (${keyframes} keyframes), ${bytes} bytes`);
-  close();
-  process.exit(0);
-});
-video.stream.on("error", (e: unknown) => {
-  console.error("stream error:", e);
-  close();
-  process.exit(1);
-});

services/discord-gateway/tests/golive-pipeline-e2e.ts

@@ -1,58 +0,0 @@
-// Phase 2 E2E: full pipeline prepareStream → demux → frame stream.
-// Run: npx tsx tests/golive-pipeline-e2e.ts
-
-import { demux } from "../src/goLive/Demuxer.js";
-import { Encoders } from "../src/goLive/Encoders.js";
-import { prepareStream } from "../src/goLive/prepareStream.js";
-import { normalizeVideoCodec } from "../src/goLive/utils.js";
-
-// Use a real ffmpeg-generated video file as input (from sample generation).
-const input = process.argv[2] ?? "/tmp/sample.h264";
-
-const prepared = prepareStream(input, {
-  encoder: Encoders.software({ x264: { preset: "superfast" } }),
-  width: 640,
-  height: 360,
-  frameRate: 25,
-  bitrateVideo: 500,
-  bitrateVideoMax: 800,
-  includeAudio: false,
-  videoCodec: normalizeVideoCodec("H264"),
-});
-
-console.log(
-  "prepareStream ok, videoCodec:",
-  prepared.videoCodec,
-  "size:",
-  prepared.width,
-  "x",
-  prepared.height,
-);
-
-const { video, close } = await demux(prepared.output, { format: "h264" });
-console.log("demux video:", video?.codecName, video?.width, "x", video?.height);
-
-let frames = 0;
-let keyframes = 0;
-video.stream.on("data", (f: { keyframe?: boolean }) => {
-  frames++;
-  if (f.keyframe) keyframes++;
-});
-video.stream.on("end", () => {
-  console.log(`pipeline frames: ${frames} (${keyframes} keyframes)`);
-  close();
-  prepared.command.kill("SIGTERM");
-  process.exit(frames > 0 ? 0 : 1);
-});
-video.stream.on("error", (e: unknown) => {
-  console.error("pipeline error:", e);
-  close();
-  prepared.command.kill("SIGTERM");
-  process.exit(1);
-});
-setTimeout(() => {
-  console.log("timeout after 30s — killing");
-  close();
-  prepared.command.kill("SIGTERM");
-  process.exit(2);
-}, 30000);

services/discord-gateway/tests/golive-videostream-e2e.ts

@@ -1,78 +0,0 @@
-// Phase 2 E2E: demux → VideoStream → native packetizer chain (local pair).
-// Run: npx tsx tests/golive-videostream-e2e.ts
-
-import { createReadStream } from "node:fs";
-import { demux } from "../src/goLive/Demuxer.js";
-import { loadNative } from "../src/goLive/native.js";
-import { VideoStream } from "../src/goLive/VideoStream.js";
-
-async function main() {
-  const native = loadNative();
-  const { PeerConnection } = native;
-
-  const pcA = new PeerConnection({ iceServers: [] });
-  const pcB = new PeerConnection({ iceServers: [] });
-
-  pcA.onStateChange(() => {});
-  pcB.onStateChange(() => {});
-
-  // Both peers declare audio+video tracks (exact passing test-packetizer
-  // pattern — tracks trigger negotiation).
-  pcA.addTrack("0", "audio");
-  pcA.addTrack("1", "video");
-  pcB.addTrack("0", "audio");
-  const trackB = pcB.addTrack("1", "video");
-  if (!trackB) throw new Error("no track from addTrack");
-
-  const track = trackB;
-  // NOTE: setPacketizer is called AFTER connected (see below) — calling it
-  // before negotiation breaks the offer (libdatachannel negotiation state).
-
-  const offer = await pcA.createOffer();
-  console.log("T1 offer");
-  pcB.setRemoteDescription(offer, "offer");
-  const answer = await pcB.createAnswer(offer);
-  console.log("T2 answer");
-  pcA.setRemoteDescription(answer, "answer");
-
-  await new Promise((r) => setTimeout(r, 1500));
-  console.log("T3 states:", pcA.state(), "/", pcB.state());
-
-  // Discord-style SSRC/payload: H264 101 @ 90kHz, playout ext id 5
-  track.setPacketizer("h264", 0x1234, 101, 90000, 5, 0, 10);
-
-  const { video, close } = await demux(createReadStream("/tmp/sample.h264"), {
-    format: "h264",
-  });
-  console.log("video stream:", video.codecName, video.width, "x", video.height);
-
-  const conn = {
-    sendVideoFrame: (frame: Buffer, frametime: number) => {
-      track.sendFrame(frame);
-      track.addTimestamp(Math.round((frametime * 90000) / 1000));
-    },
-  } as unknown as { sendVideoFrame(frame: Buffer, frametime: number): void };
-
-  const vStream = new VideoStream(conn as never);
-  let sent = 0;
-  const origSend = conn.sendVideoFrame;
-  conn.sendVideoFrame = (frame: Buffer, frametime: number) => {
-    sent++;
-    origSend(frame, frametime);
-  };
-
-  video.stream.pipe(vStream);
-  await new Promise((r) => setTimeout(r, 4000));
-
-  console.log(`sent ${sent} frames via VideoStream; B state=${pcB.state()}`);
-  const ok = sent > 0 && pcB.state() === "connected";
-  close();
-  pcA.close();
-  pcB.close();
-  process.exit(ok ? 0 : 1);
-}
-
-main().catch((e) => {
-  console.error("E2E failed:", e);
-  process.exit(1);
-});

services/discord-gateway/tests/imageCacheKey.test.ts

@@ -0,0 +1,51 @@
+// ═══════════════════════════════════════════════════════════════════════════
+// makeImageCacheKey — regression for hash collision bug
+// ═══════════════════════════════════════════════════════════════════════════
+// Bug (2026-08-12): makeImageCacheKey() only hashed the first 128 chars of the
+// data URL. Since all resized images share the same MIME prefix
+// ('data:image/png;base64,') + identical base64 header bytes, nearly every
+// image got the SAME hash → 'image:<same-hash>' → all images reused the
+// first cached vision analysis ("konten judi").
+//
+// Fix: hash the ENTIRE data URL. This test verifies the fix and prevents
+// regression.
+import { createHash } from "node:crypto";
+import { describe, expect, it } from "vitest";
+import { makeImageCacheKey } from "../src/modules/ai-moderation/textCacheStore.js";
+
+function oldBuggyHash(dataUrl: string): string {
+  const prefix = dataUrl.slice(0, 128);
+  return "image:" + createHash("sha256").update(prefix).digest("hex").slice(0, 16);
+}
+
+describe("makeImageCacheKey — collision prevention", () => {
+  it("produces different keys for images whose first 128 chars are identical", () => {
+    // Two data URLs that SHARE the first 128 chars (same MIME + identical
+    // base64 header) but differ after — this is the real-world scenario
+    // that caused the collision bug.
+    const sharedPrefix =
+      "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==" +
+      "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"; // pad to >128 chars
+
+    const imgA = sharedPrefix + "UNIQUE_TO_A";
+    const imgB = sharedPrefix + "UNIQUE_TO_B";
+
+    // Under the OLD buggy scheme: same prefix → same hash → COLLISION
+    expect(oldBuggyHash(imgA)).toBe(oldBuggyHash(imgB));
+
+    // Under the FIXED scheme: full data URL hashed → different keys
+    const keyA = makeImageCacheKey(imgA);
+    const keyB = makeImageCacheKey(imgB);
+    expect(keyA).not.toBe(keyB);
+  });
+
+  it("produces same key for identical input", () => {
+    const dataUrl = "data:image/png;base64,samebase64dataheremari";
+    expect(makeImageCacheKey(dataUrl)).toBe(makeImageCacheKey(dataUrl));
+  });
+
+  it("prefix is always 'image:'", () => {
+    const key = makeImageCacheKey("data:image/png;base64,test");
+    expect(key.startsWith("image:")).toBe(true);
+  });
+});

services/discord-gateway/tests/imageResizer.test.ts

@@ -0,0 +1,50 @@
+import { describe, expect, it } from "vitest";
+import sharp from "sharp";
+import { resizeImageForVision } from "../src/modules/attachment-upload/imageResizer.js";
+
+// Build a worst-case (poorly-compressing) 1024x1024 image, like a real photo.
+async function makeNoisyBuffer(): Promise<Buffer> {
+  const w = 1024,
+    h = 1024;
+  const buf = Buffer.alloc(w * h * 3);
+  let seed = 99;
+  const rnd = () => {
+    seed = (seed * 1103515245 + 12345) & 0x7fffffff;
+    return seed / 0x7fffffff;
+  };
+  for (let i = 0; i < buf.length; i++) buf[i] = Math.floor(rnd() * 256);
+  return sharp(buf, { raw: { width: w, height: h, channels: 3 } })
+    .png({ compressionLevel: 1 })
+    .toBuffer();
+}
+
+describe("resizeImageForVision — vision input encoding", () => {
+  it("always encodes to JPEG (not lossless PNG)", async () => {
+    const src = await makeNoisyBuffer();
+    // Source PNG is large & lossless (the old failure mode)
+    expect(src.length).toBeGreaterThan(300_000);
+
+    const { data, mimeType } = await resizeImageForVision(src, 1024);
+    expect(mimeType).toBe("image/jpeg");
+    // JPEG encoding must shrink the data URL payload well below MB range.
+    expect(data.length).toBeLessThan(800_000);
+  });
+
+  it("re-encodes already-small images (no passthrough of raw originals)", async () => {
+    const small = await sharp({
+      create: {
+        width: 200,
+        height: 200,
+        channels: 3,
+        background: { r: 200, g: 100, b: 50 },
+      },
+    })
+      .png()
+      .toBuffer();
+
+    const { data, mimeType } = await resizeImageForVision(small, 1024);
+    expect(mimeType).toBe("image/jpeg");
+    // Even a tiny PNG must come out re-encoded (bounded), not the raw PNG bytes.
+    expect(data.length).toBeLessThan(small.length);
+  });
+});

services/discord-gateway/tests/llmThinkingDisable.test.ts

@@ -0,0 +1,53 @@
+// ═══════════════════════════════════════════════════════════════════════════
+// llmClient buildLlmParams — disable-thinking injection (pure, no network)
+// ═══════════════════════════════════════════════════════════════════════════
+import { describe, expect, it } from "vitest";
+import { buildLlmParams } from "../src/modules/ai-moderation/llmClient.js";
+
+const baseOpts = {
+  messages: [{ role: "user" as const, content: "halo" }],
+};
+
+describe("buildLlmParams — disable-thinking injection", () => {
+  it("injects no thinking-disabling params when disableThinking is false", () => {
+    const params = buildLlmParams(baseOpts, false);
+    expect((params as Record<string, unknown>).reasoning_effort).toBeUndefined();
+    expect((params as Record<string, unknown>).reasoning).toBeUndefined();
+    expect(
+      (params as Record<string, unknown>).chat_template_kwargs,
+    ).toBeUndefined();
+  });
+
+  it("injects all provider variants when disableThinking is true", () => {
+    const params = buildLlmParams(baseOpts, true) as Record<string, unknown>;
+    expect(params.reasoning_effort).toBe("none");
+    expect(params.reasoning).toEqual({ enabled: false });
+    expect(params.chat_template_kwargs).toEqual({ enable_thinking: false });
+    expect(params.thinking).toEqual({ type: "disabled" });
+  });
+
+  it("keeps caller-supplied max_tokens / jsonResponse / stream intact", () => {
+    const params = buildLlmParams(
+      {
+        ...baseOpts,
+        max_tokens: 16384,
+        stream: true,
+        jsonResponse: { type: "json_object" },
+      },
+      true,
+    );
+    expect(params.max_tokens).toBe(16384);
+    expect(params.stream).toBe(true);
+    expect(params.response_format).toEqual({ type: "json_object" });
+    // thinking-disabled params still present
+    expect(
+      (params as Record<string, unknown>).chat_template_kwargs,
+    ).toEqual({ enable_thinking: false });
+  });
+
+  it("falls back to config default model when none supplied", () => {
+    // config.AI_LLM_MODEL defaults to "text"
+    const params = buildLlmParams(baseOpts, false);
+    expect(params.model).toBe("text");
+  });
+});

services/discord-gateway/tests/screenShareInput.test.ts

@@ -1,142 +0,0 @@
-// ═══════════════════════════════════════════════════════════════════════════════
-// Screen share input resolution tests
-//
-// Verifies the decision logic of getDirectScreenInput:
-//  - merged progressive URL → returned directly
-//  - video+audio DASH pair → local ffmpeg merge (Readable)
-//  - neither → rejection
-//
-// Both yt-dlp and ffmpeg are faked via PATH shim scripts so the test does not
-// hit the network or need real binaries.
-// ═══════════════════════════════════════════════════════════════════════════════
-
-import { chmodSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { Readable } from "node:stream";
-import { afterAll, beforeAll, describe, expect, it } from "vitest";
-
-import { getDirectScreenInput } from "../src/modules/voice-recording/mediaSource.js";
-
-// ─── fake bin dir ──────────────────────────────────────────────────────────────
-let fakeBinDir: string | null = null;
-const realPath = process.env.PATH;
-
-beforeAll(() => {
-  fakeBinDir = mkdtempSync(join(tmpdir(), "gmw-fake-bins-"));
-
-  // Fake yt-dlp: prints the JSON file named in GMW_FAKE_YTDLP_JSON.
-  // If the file is missing → exits 1 (mimics yt-dlp failure).
-  const ytShim = `#!/usr/bin/env bash
-if [ -n "$GMW_FAKE_YTDLP_JSON" ] && [ -f "$GMW_FAKE_YTDLP_JSON" ]; then
-  cat "$GMW_FAKE_YTDLP_JSON"
-  exit 0
-fi
-echo "yt-dlp: fake JSON missing" >&2
-exit 1
-`;
-  writeFileSync(join(fakeBinDir, "yt-dlp"), ytShim);
-  chmodSync(join(fakeBinDir, "yt-dlp"), 0o755);
-
-  // Fake ffmpeg: writes a small nut-ish payload to stdout so the returned
-  // Readable actually emits data (the merge path in mergeScreenStreams).
-  const ffShim = `#!/usr/bin/env bash
-# Fake ffmpeg — ignore args, emit a few bytes so consumers see a live stream.
-head -c 4096 /dev/urandom
-exit 0
-`;
-  writeFileSync(join(fakeBinDir, "ffmpeg"), ffShim);
-  chmodSync(join(fakeBinDir, "ffmpeg"), 0o755);
-
-  process.env.PATH = `${fakeBinDir}:${process.env.PATH}`;
-});
-
-afterAll(() => {
-  if (fakeBinDir) {
-    rmSync(fakeBinDir, { recursive: true, force: true });
-  }
-  process.env.PATH = realPath;
-});
-
-// ─── helpers ───────────────────────────────────────────────────────────────────
-function writeFakeJson(payload: Record<string, unknown>): string {
-  const p = join(
-    tmpdir(),
-    `gmw-fake-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}.json`,
-  );
-  writeFileSync(p, JSON.stringify(payload));
-  return p;
-}
-
-function dashPairInfo(videoUrl: string, audioUrl: string) {
-  return {
-    url: null,
-    acodec: "none", // top-level is not a single merged format
-    vcodec: "av01",
-    requested_formats: [
-      {
-        format_id: "136",
-        vcodec: "avc1.4d401f",
-        acodec: "none",
-        url: videoUrl,
-      },
-      { format_id: "140", vcodec: "none", acodec: "mp4a.40.2", url: audioUrl },
-    ],
-  };
-}
-
-// ─── tests ─────────────────────────────────────────────────────────────────────
-describe("getDirectScreenInput", () => {
-  it("returns the single merged progressive URL when the info has one", async () => {
-    process.env.GMW_FAKE_YTDLP_JSON = writeFakeJson({
-      url: "https://cdn.example/progressive.mp4",
-      acodec: "mp4a.40.2",
-      vcodec: "avc1",
-    });
-    const result = await getDirectScreenInput("https://youtu.be/abc");
-    expect(result).toBe("https://cdn.example/progressive.mp4");
-  });
-
-  it("returns a live Readable when a video+audio DASH pair must be merged", async () => {
-    process.env.GMW_FAKE_YTDLP_JSON = writeFakeJson(
-      dashPairInfo(
-        "https://cdn.example/video.mp4",
-        "https://cdn.example/audio.m4a",
-      ),
-    );
-    const result = await getDirectScreenInput("https://youtu.be/abc");
-    expect(Readable.isReadable(result)).toBe(true);
-
-    // The fake ffmpeg emits bytes; collect a chunk to prove the stream flows.
-    const bytes = await new Promise<number>((resolve, reject) => {
-      const stream = result as Readable;
-      let got = 0;
-      stream.on("data", (chunk: Buffer) => {
-        got += chunk.length;
-      });
-      stream.on("error", reject);
-      stream.on("end", () => resolve(got));
-      stream.resume();
-    });
-    expect(bytes).toBeGreaterThan(0);
-  });
-
-  it("rejects when yt-dlp returns neither a merged URL nor a format pair", async () => {
-    process.env.GMW_FAKE_YTDLP_JSON = writeFakeJson({
-      url: null,
-      acodec: "none",
-      vcodec: "none",
-      requested_formats: [],
-    });
-    await expect(getDirectScreenInput("https://youtu.be/abc")).rejects.toThrow(
-      /neither a merged progressive URL nor a video\+audio/,
-    );
-  });
-
-  it("rejects when yt-dlp exits non-zero", async () => {
-    process.env.GMW_FAKE_YTDLP_JSON = "/nonexistent/gmw-fake.json";
-    await expect(getDirectScreenInput("https://youtu.be/abc")).rejects.toThrow(
-      /screen input resolution exited with code 1/,
-    );
-  });
-});

services/discord-gateway/tests/termGlossary.test.ts

@@ -0,0 +1,91 @@
+// ═══════════════════════════════════════════════════════════════════════════
+// Term glossary — pure extraction/formatting tests (no DB, Redis, or network)
+// ═══════════════════════════════════════════════════════════════════════════
+import { describe, expect, it } from "vitest";
+import {
+  extractGlossaryTerms,
+  formatTermGlossary,
+} from "../src/modules/ai-moderation/termGlossary.js";
+
+describe("extractGlossaryTerms — filters out words the LLM already knows", () => {
+  it("returns [] for common conversational Indonesian", () => {
+    const terms = extractGlossaryTerms(
+      ["anjay mabar yuk gaskeun gua gas", "iya bener banget sih"],
+      { maxTerms: 6 },
+    );
+    expect(terms).toEqual([]);
+  });
+
+  it("extracts uncommon/foreign-looking words and skips stopwords + brands", () => {
+    const terms = extractGlossaryTerms(
+      [
+        "tadi gua baca soal tempeh di discord",
+        "kayaknya istilahnya shirkmaxxing deh",
+      ],
+      { maxTerms: 6 },
+    );
+    // "tempeh" and "shirkmaxxing" are candidates; "discord"/"istilahnya" are not
+    expect(terms).toContain("tempeh");
+    expect(terms).toContain("shirkmaxxing");
+    expect(terms).not.toContain("discord");
+    expect(terms).not.toContain("istilahnya");
+  });
+
+  it("strips URLs, mentions, and custom emoji before extracting", () => {
+    const terms = extractGlossaryTerms(
+      ["cek https://example.com/foo <@123456> <:hadeh:987> kafircel"],
+      { maxTerms: 6 },
+    );
+    expect(terms).toContain("kafircel");
+    expect(terms.some((t) => /example|hadeh|123/.test(t))).toBe(false);
+  });
+
+  it("extracts quoted phrases as a single term", () => {
+    const terms = extractGlossaryTerms(['dia bilang "kostum hewan" itu aneh'], {
+      maxTerms: 6,
+    });
+    expect(terms).toContain("kostum hewan");
+  });
+
+  it("skips repeated-char noise like wkwkwk and aaaaa", () => {
+    const terms = extractGlossaryTerms(["wkwkwkwk aaaaa xixixi"], {
+      maxTerms: 6,
+    });
+    expect(terms).toEqual([]);
+  });
+
+  it("respects maxTerms and prioritizes proper nouns", () => {
+    const terms = extractGlossaryTerms(
+      ["aku suka Xenogears sama Chrono Cross terus Yakuza"],
+      { maxTerms: 2 },
+    );
+    expect(terms.length).toBeLessThanOrEqual(2);
+    expect(terms[0]).toBe("Xenogears");
+  });
+});
+
+describe("formatTermGlossary — XML block shape", () => {
+  it("returns '' for an empty map", () => {
+    expect(formatTermGlossary(new Map())).toBe("");
+  });
+
+  it("wraps definitions in <term_glossary> with escaped attributes/content", () => {
+    const block = formatTermGlossary(
+      new Map([
+        [
+          "kafircel",
+          {
+            term: "kafircel",
+            definition: "sebutan <memes> untuk & orang",
+            sourceUrl: "https://id.wikipedia.org/wiki/Mem",
+          },
+        ],
+      ]),
+    );
+    expect(block).toContain("<term_glossary>");
+    expect(block).toContain('<term word="kafircel"');
+    expect(block).toContain("&lt;memes&gt;");
+    expect(block).toContain("&amp;");
+    expect(block).toContain("</term_glossary>");
+  });
+});

services/frontend/next.config.ts

@@ -1,13 +1,8 @@
 import type { NextConfig } from "next";
 
 const nextConfig: NextConfig = {
-  reactCompiler: true,
-  // SSR — pages render on the server; realtime stays client-side via WS.
-  // No static export: shared state (voice, media, moderation) is served
-  // from the backend at render-time on the server.
   output: "standalone",
   trailingSlash: true,
-  images: { unoptimized: true },
 };
 
 export default nextConfig;

services/frontend/package.json

@@ -10,27 +10,16 @@
     "format": "biome format --write"
   },
   "dependencies": {
-    "@base-ui/react": "^1.6.0",
-    "@shadcn/react": "^0.2.1",
-    "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",
-    "cmdk": "^1.1.1",
-    "date-fns": "^4.4.0",
-    "embla-carousel-react": "^8.6.0",
-    "input-otp": "^1.4.2",
     "lucide-react": "^1.27.0",
+    "motion": "^12.0.0",
     "next": "16.2.12",
     "next-themes": "^0.4.6",
     "react": "19.2.4",
-    "react-day-picker": "^10.0.1",
     "react-dom": "19.2.4",
-    "react-resizable-panels": "^4.12.2",
-    "recharts": "3.8.0",
-    "shadcn": "^4.15.0",
-    "sonner": "^2.0.7",
     "swr": "^2.4.2",
     "tailwind-merge": "^3.6.0",
-    "tw-animate-css": "^1.4.0"
+    "three": "^0.180.0"
   },
   "devDependencies": {
     "@biomejs/biome": "2.2.0",
@@ -38,7 +27,9 @@
     "@types/node": "^20",
     "@types/react": "^19",
     "@types/react-dom": "^19",
+    "@types/three": "^0.180.0",
     "babel-plugin-react-compiler": "1.0.0",
+    "puppeteer-core": "^25.7.0",
     "tailwindcss": "^4",
     "typescript": "^5"
   }

services/frontend/src/app/(dashboard)/analysis/page.tsx

@@ -1,11 +1,7 @@
-"use client";
+import { AnalysisView } from "./view";
 
-import { SearchPanel } from "@/components/analysis/search-panel";
+export const dynamic = "force-dynamic";
 
 export default function AnalysisPage() {
-  return (
-    <div className="space-y-5 animate-fade-in-up">
-      <SearchPanel />
-    </div>
-  );
+  return <AnalysisView />;
 }

services/frontend/src/app/(dashboard)/analysis/view.tsx

@@ -0,0 +1,190 @@
+"use client";
+
+import { Hash, Search, Sparkles, TrendingUp } from "lucide-react";
+import { useEffect, useState } from "react";
+import { useAmbient } from "@/components/ambient/ambient-context";
+import { Avatar, Badge, GlassPanel, Input } from "@/components/primitives";
+import { EmptyState, LoadingState, SectionHeader } from "@/components/shared";
+import { useChannels, useMessageSearch, useTopReactors } from "@/hooks";
+import { getMessageChannelLabel, renderMessageContent } from "@/lib/format";
+import type { AiStatus } from "@/lib/types";
+
+function aiTone(
+  s?: AiStatus | null,
+): "signal" | "amber" | "vermilion" | "neutral" {
+  if (s === "clean") return "signal";
+  if (s === "warn") return "amber";
+  if (s === "flagged" || s === "error") return "vermilion";
+  return "neutral";
+}
+
+/** Human-readable analysis duration, e.g. 850ms / 1.2s / 3.4s. */
+function formatAnalysisDuration(ms: number): string {
+  if (ms < 1000) return `${Math.round(ms)}ms`;
+  return `${(ms / 1000).toFixed(1)}s`;
+}
+
+export function AnalysisView() {
+  const [query, setQuery] = useState("");
+  const search = useMessageSearch(query, query.trim().length >= 2);
+  const { data: reactors } = useTopReactors();
+  const { data: channels } = useChannels();
+  const ambient = useAmbient();
+
+  useEffect(() => {
+    ambient.set(
+      query ? "amber" : "signal",
+      0.3,
+      query ? "analyzing" : "search",
+    );
+  }, [query, ambient]);
+
+  return (
+    <div className="space-y-5">
+      <GlassPanel glow className="relative overflow-hidden">
+        <div className="scan-line absolute inset-x-0 top-0" />
+        <div className="flex items-center gap-3">
+          <Sparkles className="size-5 text-signal" />
+          <div>
+            <div className="eyebrow">Semantic search</div>
+            <h2 className="display text-2xl text-ink">Search the archive</h2>
+          </div>
+        </div>
+        <div className="relative mt-4">
+          <Search className="absolute left-4 top-1/2 size-5 -translate-y-1/2 text-ink-faint" />
+          <Input
+            className="h-12 pl-12 text-base"
+            placeholder="Find messages, patterns, flags…"
+            value={query}
+            onChange={(e) => setQuery(e.target.value)}
+            autoFocus
+          />
+        </div>
+        {query.trim().length > 0 && query.trim().length < 2 && (
+          <div className="mono mt-2 text-xs text-ink-faint">
+            Type at least 2 characters…
+          </div>
+        )}
+      </GlassPanel>
+
+      <div className="grid gap-5 lg:grid-cols-5">
+        <GlassPanel className="lg:col-span-3">
+          <SectionHeader
+            eyebrow="results"
+            title="Matches"
+            action={
+              <span className="mono text-xs text-ink-faint">
+                {(search.data ?? []).length}
+              </span>
+            }
+          />
+          {query.trim().length >= 2 && search.isLoading && (
+            <LoadingState label="Scanning" />
+          )}
+          {(search.data ?? []).length === 0 ? (
+            <EmptyState
+              icon={<Search className="size-7" />}
+              title="No matches yet"
+              description="Run a search to surface messages across the guild."
+            />
+          ) : (
+            <div className="space-y-1.5">
+              {(search.data ?? []).map((m) => (
+                <div
+                  key={m.id}
+                  className="flex items-start gap-3 rounded-[12px] border border-hairline bg-white/[0.03] p-3"
+                >
+                  <Avatar src={m.avatar_url} name={m.username} size={32} />
+                  <div className="min-w-0 flex-1">
+                    <div className="flex items-center gap-2">
+                      <span className="text-sm font-semibold text-ink">
+                        {m.username}
+                      </span>
+                      <span className="mono text-[0.65rem] text-ink-faint">
+                        {getMessageChannelLabel(m)}
+                      </span>
+                      {m.ai_status && (
+                        <Badge tone={aiTone(m.ai_status)} className="ml-auto">
+                          {m.ai_analysis_duration_ms &&
+                          m.ai_analysis_duration_ms > 0
+                            ? `${m.ai_status} · ${formatAnalysisDuration(m.ai_analysis_duration_ms)}`
+                            : m.ai_status}
+                        </Badge>
+                      )}
+                    </div>
+                    <div className="mt-0.5 text-sm text-ink-soft">
+                      {renderMessageContent(m.content, m.metadata) || "(embed)"}
+                    </div>
+                  </div>
+                </div>
+              ))}
+            </div>
+          )}
+        </GlassPanel>
+
+        <div className="space-y-5 lg:col-span-2">
+          <GlassPanel>
+            <SectionHeader
+              eyebrow="culture"
+              title={
+                <span className="flex items-center gap-2">
+                  <TrendingUp className="size-4 text-signal" /> Top reactors
+                </span>
+              }
+            />
+            <div className="space-y-2">
+              {(reactors ?? []).slice(0, 6).map((r, i) => (
+                <div
+                  key={r.user_id}
+                  className="flex items-center gap-3 text-sm"
+                >
+                  <span className="mono w-5 text-ink-faint">{i + 1}</span>
+                  <span className="flex-1 truncate text-ink">{r.username}</span>
+                  <span className="mono text-xs text-signal">
+                    +{r.net_count}
+                  </span>
+                </div>
+              ))}
+              {(reactors ?? []).length === 0 && (
+                <div className="py-4 text-center text-xs text-ink-faint">
+                  No data
+                </div>
+              )}
+            </div>
+          </GlassPanel>
+
+          <GlassPanel>
+            <SectionHeader
+              eyebrow="channels"
+              title={
+                <span className="flex items-center gap-2">
+                  <Hash className="size-4 text-signal" /> Top channels
+                </span>
+              }
+            />
+            <div className="space-y-2">
+              {(channels ?? []).slice(0, 6).map((c) => (
+                <div
+                  key={c.channel_id}
+                  className="flex items-center gap-3 text-sm"
+                >
+                  <span className="flex-1 truncate text-ink-soft">
+                    {c.channel_name ?? c.channel_id.slice(0, 8)}
+                  </span>
+                  <span className="mono text-xs text-ink-faint">
+                    {c.total_messages}
+                  </span>
+                </div>
+              ))}
+              {(channels ?? []).length === 0 && (
+                <div className="py-4 text-center text-xs text-ink-faint">
+                  No data
+                </div>
+              )}
+            </div>
+          </GlassPanel>
+        </div>
+      </div>
+    </div>
+  );
+}

services/frontend/src/app/(dashboard)/dashboard/page.tsx

@@ -1,25 +1,18 @@
-/**
- * Dashboard page — Server Component.
- *
- * Fetches y the initial stats + activity on the server (no client round-trip
- * for first paint) and hands them to the hydrated client view. This is the
- * "data on the server" leg of the reworked data flow.
- */
 import { getActivity, getDashboardStats } from "@/lib/api/server";
-import DashboardView from "./view";
+import { DashboardView } from "./view";
+
+export const dynamic = "force-dynamic";
 
 export default async function DashboardPage() {
-  const [stats, activity] = await Promise.allSettled([
+  let stats: Awaited<ReturnType<typeof getDashboardStats>> | undefined;
+  let activity: Awaited<ReturnType<typeof getActivity>> | undefined;
+  try {
+    [stats, activity] = await Promise.all([
       getDashboardStats(),
       getActivity(14),
     ]);
-
-  return (
-    <DashboardView
-      initialStats={stats.status === "fulfilled" ? stats.value : undefined}
-      initialActivity={
-        activity.status === "fulfilled" ? activity.value : undefined
+  } catch {
+    // Backend unavailable — client hooks will surface the error state.
   }
-    />
-  );
+  return <DashboardView initialStats={stats} initialActivity={activity} />;
 }

services/frontend/src/app/(dashboard)/dashboard/view.tsx

@@ -1,188 +1,332 @@
 "use client";
 
 import {
-  AlertCircle,
-  Clock,
-  Hash,
-  Heart,
-  Shield,
-  Sparkles,
+  Activity,
+  Flag,
+  MessageSquare,
+  Mic,
+  Radio,
+  ShieldAlert,
   Users,
 } from "lucide-react";
-import { useState } from "react";
-import { ActivityChart } from "@/components/dashboard/activity-chart";
-import { ChannelsSection } from "@/components/dashboard/channels-section";
-import { HourlyActivityChart } from "@/components/dashboard/hourly-activity-chart";
-import { ModerationDonut } from "@/components/dashboard/moderation-donut";
-import { ReactionsSection } from "@/components/dashboard/reactions-section";
-import { StatCard } from "@/components/dashboard/stat-card";
-import { TopChannelsChart } from "@/components/dashboard/top-channels-chart";
-import { UsersSection } from "@/components/dashboard/users-section";
-import { SubNav } from "@/components/layout/sub-nav";
-import { ErrorState, LoadingSkeleton } from "@/components/shared";
-import { useActivity, useStats } from "@/hooks";
-import type { DashboardActivity, DashboardStats } from "@/lib/types";
-import { cn } from "@/lib/utils";
+import { useEffect } from "react";
+import { useAmbient } from "@/components/ambient/ambient-context";
+import { AreaActivity, RadialGauge } from "@/components/charts";
+import { GlassPanel } from "@/components/primitives";
+import { ErrorState, LoadingState } from "@/components/shared";
+import { MetricTile, SectionHeader } from "@/components/shared/section";
+import {
+  useActivity,
+  useStats,
+  useTopReactions,
+  useTopReactors,
+} from "@/hooks";
+import { formatNumber } from "@/lib/format";
+import type { DashboardStats } from "@/lib/types";
 
-type DashboardTab = "stats" | "users" | "channels" | "reactions";
+function deriveSignal(stats?: DashboardStats) {
+  if (!stats) return { tone: "signal" as const, label: "nominal" };
+  const total = stats.total_flagged + stats.total_clean || 1;
+  const ratio = stats.total_flagged / total;
+  if (stats.moderation_overview.error > 0)
+    return { tone: "vermilion" as const, label: "moderation fault" };
+  if (ratio > 0.25)
+    return { tone: "vermilion" as const, label: "elevated flags" };
+  if (ratio > 0.1) return { tone: "amber" as const, label: "watch" };
+  return { tone: "signal" as const, label: "nominal" };
+}
 
-const DAY_RANGES = [7, 14, 30] as const;
-
-const MODERATION_COLORS: Record<string, string> = {
-  Clean: "oklch(0.72 0.16 155)",
-  Flagged: "oklch(0.62 0.19 25)",
-  Warned: "oklch(0.78 0.15 80)",
-  Error: "oklch(0.55 0.02 245)",
-};
-
-/**
- * Dashboard view — hydrated on the client but seeded with server-rendered
- * initial data. SWR takes over for revalidation after first paint.
- */
-export default function DashboardView({
+export function DashboardView({
   initialStats,
   initialActivity,
 }: {
   initialStats?: DashboardStats;
-  initialActivity?: DashboardActivity;
+  initialActivity?: Awaited<ReturnType<typeof useActivity>>["data"];
 }) {
-  const [tab, setTab] = useState<DashboardTab>("stats");
-  const [days, setDays] = useState<number>(14);
-  const { data: stats, error, mutate: refetch } = useStats(initialStats);
-  const { data: activity } = useActivity(
-    days,
-    days === 14 ? initialActivity : undefined,
+  const { data: stats, isLoading, error } = useStats(initialStats);
+  const { data: activity } = useActivity(14, initialActivity as never);
+  const { data: reactors } = useTopReactors();
+  const { data: reactions } = useTopReactions();
+  const ambient = useAmbient();
+
+  useEffect(() => {
+    const s = deriveSignal(stats);
+    ambient.set(
+      s.tone,
+      0.3 + Math.min(0.5, (stats?.today_flagged ?? 0) / 50),
+      s.label,
     );
+  }, [stats, ambient]);
 
-  const subNavTabs = [
-    { id: "stats", label: "Stats", icon: <Hash className="size-3" /> },
-    { id: "users", label: "Users", icon: <Users className="size-3" /> },
-    { id: "channels", label: "Channels", icon: <Hash className="size-3" /> },
-    { id: "reactions", label: "Reactions", icon: <Heart className="size-3" /> },
-  ];
+  if (error && !stats) return <ErrorState error={error} />;
+  if (!stats && isLoading) return <LoadingState label="Reading grid" />;
+  if (!stats) return <ErrorState error={error ?? new Error("No data")} />;
 
-  const moderationData = stats
-    ? [
-        {
-          name: "Clean",
-          value: stats.total_clean,
-          color: MODERATION_COLORS.Clean,
-        },
-        {
-          name: "Flagged",
-          value: stats.total_flagged,
-          color: MODERATION_COLORS.Flagged,
-        },
-        {
-          name: "Warned",
-          value: stats.total_warned,
-          color: MODERATION_COLORS.Warned,
-        },
-        {
-          name: "Error",
-          value: stats.total_error,
-          color: MODERATION_COLORS.Error,
-        },
-      ].filter((d) => d.value > 0)
-    : [];
+  const s = stats;
+  const total = s.total_flagged + s.total_clean || 1;
+  const cleanRatio = s.total_clean / total;
 
   return (
-    <div className="space-y-4 animate-fade-in-up">
-      <SubNav
-        tabs={subNavTabs}
-        activeTab={tab}
-        onTabChange={(t) => setTab(t as DashboardTab)}
-      />
-
-      {tab === "stats" && (
-        <div className="space-y-4">
-          {error ? (
-            <ErrorState message={error.message} onRetry={refetch} />
-          ) : !stats ? (
-            <LoadingSkeleton count={6} height="h-28" columns={3} />
-          ) : (
-            <>
-              <div className="grid grid-cols-2 md:grid-cols-3 lg:grid-cols-6 gap-3">
-                <StatCard
-                  label="Total Messages"
-                  value={stats.total_messages}
-                  icon={Hash}
-                />
-                <StatCard
-                  label="Today"
-                  value={stats.today_messages}
-                  icon={Clock}
-                />
-                <StatCard
-                  label="Users"
-                  value={stats.total_users}
-                  icon={Users}
-                />
-                <StatCard
-                  label="Active 24h"
-                  value={stats.active_users_24h}
-                  icon={Sparkles}
-                />
-                <StatCard
-                  label="Flagged"
-                  value={stats.total_flagged}
-                  icon={AlertCircle}
-                  variant="danger"
-                />
-                <StatCard
-                  label="Clean"
-                  value={stats.total_clean}
-                  icon={Shield}
-                  variant="success"
-                />
+    <div className="space-y-5">
+      {/* Hero */}
+      <GlassPanel glow className="relative overflow-hidden">
+        <div className="scan-line absolute inset-x-0 top-0" />
+        <div className="flex flex-wrap items-end justify-between gap-4">
+          <div>
+            <div className="eyebrow mb-2">GMW · Operations Grid</div>
+            <h2 className="display text-[2.6rem] leading-none text-ink glow-signal">
+              Ambient Field
+            </h2>
+            <p className="mt-2 max-w-md text-sm text-ink-soft">
+              Real-time moderation, voice & media presence across the monitored
+              guild. {formatNumber(s.total_messages)} messages captured.
+            </p>
+          </div>
+          <div className="flex items-center gap-2 text-ink-soft">
+            <Radio className="size-4 text-signal animate-breathe" />
+            <span className="mono text-xs uppercase tracking-wider">
+              {deriveSignal(s).label}
+            </span>
+          </div>
         </div>
 
-              <div className="flex items-center justify-end gap-1">
-                {DAY_RANGES.map((range) => (
-                  <button
-                    key={range}
-                    type="button"
-                    onClick={() => setDays(range)}
-                    className={cn(
-                      "px-2.5 py-1 text-[10px] font-medium uppercase tracking-wide rounded-md transition-colors",
-                      days === range
-                        ? "bg-primary/20 text-primary"
-                        : "text-text-secondary/60 hover:text-text-primary",
+        <div className="mt-5 grid grid-cols-2 gap-3 md:grid-cols-4">
+          <MetricTile
+            label="Messages"
+            value={formatNumber(s.total_messages)}
+            tone="signal"
+            icon={<MessageSquare className="size-3.5" />}
+          />
+          <MetricTile
+            label="Flagged"
+            value={formatNumber(s.total_flagged)}
+            tone={s.total_flagged > 0 ? "vermilion" : "neutral"}
+            hint={`${s.today_flagged} today`}
+          />
+          <MetricTile
+            label="Active 24h"
+            value={formatNumber(s.active_users_24h)}
+            tone="signal"
+            icon={<Users className="size-3.5" />}
+          />
+          <MetricTile
+            label="Voice clips"
+            value={formatNumber(s.total_voice_recordings)}
+            icon={<Mic className="size-3.5" />}
+          />
+        </div>
+      </GlassPanel>
+
+      {/* Activity */}
+      <GlassPanel>
+        <SectionHeader
+          eyebrow="14-day signal"
+          title={
+            <span className="flex items-center gap-2">
+              <Activity className="size-4 text-signal" /> Activity & moderation
+            </span>
+          }
+          action={
+            <div className="flex items-center gap-3 text-xs text-ink-soft">
+              <span className="flex items-center gap-1.5">
+                <span className="size-2 rounded-full bg-signal" /> messages
+              </span>
+              <span className="flex items-center gap-1.5">
+                <span className="size-2 rounded-full bg-vermilion" /> flagged
+              </span>
+            </div>
+          }
+        />
+        {activity ? (
+          <AreaActivity daily={activity.daily} />
+        ) : (
+          <LoadingState label="streaming" />
         )}
+      </GlassPanel>
+
+      {/* Two-column: channels + moderation */}
+      <div className="grid gap-5 lg:grid-cols-5">
+        <GlassPanel className="lg:col-span-3">
+          <SectionHeader eyebrow="throughput" title="Top channels" />
+          <div className="space-y-2.5">
+            {s.top_channels.slice(0, 7).map((c) => {
+              const pct =
+                (c.message_count / (s.top_channels[0]?.message_count || 1)) *
+                100;
+              return (
+                <div key={c.channel_id} className="flex items-center gap-3">
+                  <span className="w-40 truncate text-sm text-ink-soft">
+                    {c.channel_name ?? c.channel_id.slice(0, 8)}
+                  </span>
+                  <div className="h-2 flex-1 overflow-hidden rounded-full bg-white/8">
+                    <div
+                      className="h-full rounded-full bg-signal/70"
+                      style={{ width: `${pct}%` }}
+                    />
+                  </div>
+                  <span className="mono w-14 text-right text-xs text-ink-faint">
+                    {formatNumber(c.message_count)}
+                  </span>
+                </div>
+              );
+            })}
+          </div>
+        </GlassPanel>
+
+        <GlassPanel className="lg:col-span-2">
+          <SectionHeader eyebrow="trust" title="Moderation" />
+          <div className="flex items-center gap-5">
+            <RadialGauge
+              value={cleanRatio}
+              tone={
+                cleanRatio > 0.8
+                  ? "signal"
+                  : cleanRatio > 0.6
+                    ? "amber"
+                    : "vermilion"
+              }
+              label={`${Math.round(cleanRatio * 100)}%`}
+              sublabel="clean"
+            />
+            <div className="flex-1 space-y-2 text-sm">
+              <Row
+                icon={<ShieldAlert className="size-4 text-signal" />}
+                label="Clean"
+                value={formatNumber(s.total_clean)}
+              />
+              <Row
+                icon={<Flag className="size-4 text-vermilion" />}
+                label="Flagged"
+                value={formatNumber(s.total_flagged)}
+              />
+              <Row
+                icon={<Activity className="size-4 text-amber" />}
+                label="Warned"
+                value={formatNumber(s.total_warned)}
+              />
+            </div>
+          </div>
+          <div className="mt-4 flex items-center justify-around border-t border-hairline pt-3 text-center">
+            <Mini
+              label="pending"
+              value={s.moderation_overview.pending}
+              tone="amber"
+            />
+            <Mini
+              label="processing"
+              value={s.moderation_overview.processing}
+              tone="signal"
+            />
+            <Mini
+              label="errors"
+              value={s.moderation_overview.error}
+              tone="vermilion"
+            />
+          </div>
+        </GlassPanel>
+      </div>
+
+      {/* Reactors + reactions */}
+      <div className="grid gap-5 lg:grid-cols-2">
+        <GlassPanel>
+          <SectionHeader eyebrow="engagement" title="Top reactors" />
+          <div className="space-y-2">
+            {(reactors ?? []).slice(0, 6).map((r, i) => (
+              <div key={r.user_id} className="flex items-center gap-3">
+                <span className="mono w-5 text-ink-faint">{i + 1}</span>
+                <span className="flex-1 truncate text-sm text-ink">
+                  {r.username}
+                </span>
+                <span className="mono text-xs text-signal">
+                  +{formatNumber(r.net_count)}
+                </span>
+              </div>
+            ))}
+            {(reactors ?? []).length === 0 && <EmptyHint />}
+          </div>
+        </GlassPanel>
+
+        <GlassPanel>
+          <SectionHeader eyebrow="culture" title="Top reactions" />
+          <div className="space-y-3">
+            {(reactions ?? []).slice(0, 5).map((m) => (
+              <div key={m.message_id} className="flex items-start gap-3">
+                <div className="flex flex-wrap gap-1 pt-0.5">
+                  {m.top_emojis.slice(0, 3).map((e, i) => (
+                    <span
+                      key={`${m.message_id}-${i}`}
+                      className="text-lg leading-none"
                     >
-                    {range}d
-                  </button>
+                      {e.emoji}
+                    </span>
                   ))}
                 </div>
-
-              <div className="grid grid-cols-1 gap-4 xl:grid-cols-3">
-                <div className="xl:col-span-2">
-                  {activity && <ActivityChart data={activity.daily} />}
+                <div className="min-w-0 flex-1">
+                  <div className="truncate text-sm text-ink">
+                    {m.content || "(no text)"}
                   </div>
-                <ModerationDonut data={moderationData} />
+                  <div className="mono text-[0.65rem] text-ink-faint">
+                    {m.username} · {m.channel_name ?? m.channel_id.slice(0, 8)}
                   </div>
-
-              <div className="grid grid-cols-1 gap-4 xl:grid-cols-3">
-                <div className="xl:col-span-2">
-                  {activity && <HourlyActivityChart data={activity.hourly} />}
                 </div>
-                <TopChannelsChart
-                  data={stats.top_channels.map((c) => ({
-                    name: c.channel_name ?? c.channel_id,
-                    count: c.message_count,
-                  }))}
-                />
+                <span className="mono text-xs text-ink-soft">
+                  {m.reaction_count}
+                </span>
               </div>
-            </>
-          )}
+            ))}
+            {(reactions ?? []).length === 0 && <EmptyHint />}
+          </div>
+        </GlassPanel>
       </div>
-      )}
+    </div>
+  );
+}
 
-      {tab === "users" && <UsersSection />}
+function Row({
+  icon,
+  label,
+  value,
+}: {
+  icon: React.ReactNode;
+  label: string;
+  value: string;
+}) {
+  return (
+    <div className="flex items-center gap-2.5">
+      {icon}
+      <span className="flex-1 text-ink-soft">{label}</span>
+      <span className="mono text-ink">{value}</span>
+    </div>
+  );
+}
 
-      {tab === "channels" && <ChannelsSection />}
+function Mini({
+  label,
+  value,
+  tone,
+}: {
+  label: string;
+  value: number;
+  tone: "signal" | "amber" | "vermilion";
+}) {
+  const color =
+    tone === "vermilion"
+      ? "text-vermilion"
+      : tone === "amber"
+        ? "text-amber"
+        : "text-signal";
+  return (
+    <div>
+      <div className={`display text-xl ${color}`}>{value}</div>
+      <div className="eyebrow mt-0.5">{label}</div>
+    </div>
+  );
+}
 
-      {tab === "reactions" && <ReactionsSection />}
+function EmptyHint() {
+  return (
+    <div className="py-6 text-center text-xs text-ink-faint">
+      Awaiting data…
     </div>
   );
 }

services/frontend/src/app/(dashboard)/layout.tsx

@@ -1,120 +1,19 @@
-"use client";
-
-import { Suspense, useEffect, useState } from "react";
-import { SWRConfig } from "swr";
-import { ChatbotContainer } from "@/components/chatbot/chatbot-container";
-import {
-  ChatbotProvider,
-  useChatbot,
-} from "@/components/chatbot/chatbot-context";
-import { AppSidebar } from "@/components/layout/app-sidebar";
-import { MiniPlayer } from "@/components/media/mini-player";
-import { GuildSelector } from "@/components/shared/guild-selector";
-import { Separator } from "@/components/ui/separator";
-import {
-  SidebarInset,
-  SidebarProvider,
-  SidebarTrigger,
-} from "@/components/ui/sidebar";
-import { MediaPlayerProvider } from "@/lib/hooks/use-media-player";
-import { useWebSocket, WsProvider } from "@/lib/ws/context";
-
-function ChatbotGuildSync({ guildId }: { guildId: string }) {
-  const { setGuildId } = useChatbot();
-
-  useEffect(() => {
-    setGuildId(guildId);
-  }, [guildId, setGuildId]);
-
-  return null;
-}
-
-function ChatbotExpressionSync() {
-  const ws = useWebSocket();
-  const { setExpression } = useChatbot();
-  useEffect(() => {
-    const unsub1 = ws.on("message_created", (data: any) => {
-      if (data.ai_status === "flagged" || data.ai_status === "warn") {
-        setExpression("surprise");
-        setTimeout(() => setExpression("idle"), 2000);
-      }
-    });
-
-    const unsub2 = ws.on("voice_active_user", () => {
-      setExpression("listening");
-    });
-
-    return () => {
-      unsub1();
-      unsub2();
-    };
-  }, [ws, setExpression]);
-
-  return null;
-}
+import { AmbientProvider } from "@/components/ambient/ambient-context";
+import { Chatbot } from "@/components/chatbot/chatbot";
+import { CommandPalette } from "@/components/command/command-palette";
+import { AppFrame } from "@/components/shell";
+import { WsProvider } from "@/lib/ws/context";
 
 export default function DashboardLayout({
   children,
-}: {
-  children: React.ReactNode;
-}) {
-  const [guildId, setGuildId] = useState("");
-
+}: Readonly<{ children: React.ReactNode }>) {
   return (
-    <SWRConfig
-      value={{
-        revalidateOnFocus: false,
-        dedupingInterval: 10_000,
-        shouldRetryOnError: (err) =>
-          (err as { statusCode?: number })?.statusCode !== 404,
-      }}
-    >
+    <AmbientProvider>
       <WsProvider>
-        <MediaPlayerProvider>
-          <ChatbotProvider>
-            <ChatbotGuildSync guildId={guildId} />
-            <ChatbotExpressionSync />
-            <div className="min-h-svh bg-canvas">
-              <SidebarProvider>
-                <AppSidebar />
-                <SidebarInset className="gap-0">
-                  <header className="flex h-14 shrink-0 items-center gap-2 border-b px-4 bg-canvas">
-                    <SidebarTrigger className="-ml-1" />
-                    <Separator
-                      orientation="vertical"
-                      className="mr-2 h-6 max-md:hidden"
-                    />
-                    <div className="font-semibold max-md:hidden">Overview</div>
-                    <div className="ms-auto">
-                      <GuildSelector
-                        value={guildId}
-                        onChange={(g) => setGuildId(g ?? "")}
-                      />
-                    </div>
-                  </header>
-
-                  <main className="flex flex-1 flex-col gap-4 p-4 pb-28 md:p-6 lg:pb-8">
-                    <div className="mx-auto w-full max-w-[1440px]">
-                      <Suspense
-                        fallback={
-                          <div className="flex h-[60vh] items-center justify-center">
-                            <div className="size-8 rounded-full border-2 border-primary border-t-transparent animate-spin" />
-                          </div>
-                        }
-                      >
-                        {children}
-                      </Suspense>
-                    </div>
-                  </main>
-                </SidebarInset>
-              </SidebarProvider>
-
-              <MiniPlayer />
-              <ChatbotContainer />
-            </div>
-          </ChatbotProvider>
-        </MediaPlayerProvider>
+        <AppFrame>{children}</AppFrame>
+        <Chatbot />
+        <CommandPalette />
       </WsProvider>
-    </SWRConfig>
+    </AmbientProvider>
   );
 }

services/frontend/src/app/(dashboard)/media/page.tsx

@@ -1,13 +1,14 @@
-/**
- * Media page — Server Component. Seeds the music player with the shared media
- * state fetched on the server (same state every user sees), then live-updates
- * over WS.
- */
 import { getMediaStatus } from "@/lib/api/server";
-import MediaView from "./view";
+import { MediaView } from "./view";
+
+export const dynamic = "force-dynamic";
 
 export default async function MediaPage() {
-  const status = await getMediaStatus().catch(() => undefined);
-
+  let status: import("@/lib/types").MediaState | undefined;
+  try {
+    status = await getMediaStatus();
+  } catch {
+    /* client hooks surface errors */
+  }
   return <MediaView initialStatus={status} />;
 }

services/frontend/src/app/(dashboard)/media/view.tsx

@@ -1,19 +1,183 @@
 "use client";
 
-import { MusicPlayer } from "@/components/media/music-player";
+import {
+  ListMusic,
+  Play,
+  Radio,
+  Repeat,
+  SkipForward,
+  Square,
+} from "lucide-react";
+import { useEffect, useState } from "react";
+import { useAmbient } from "@/components/ambient/ambient-context";
+import { Button, GlassPanel, Input, toast } from "@/components/primitives";
+import { ErrorState, LoadingState, SectionHeader } from "@/components/shared";
+import {
+  useMediaLoop,
+  useMediaQueue,
+  useMediaSkip,
+  useMediaState,
+  useMediaStop,
+  useMediaWsSync,
+} from "@/hooks";
 import type { MediaState } from "@/lib/types";
 import { useWebSocket } from "@/lib/ws/context";
 
-export default function MediaView({
-  initialStatus,
-}: {
-  initialStatus?: MediaState;
-}) {
+export function MediaView({ initialStatus }: { initialStatus?: MediaState }) {
   const ws = useWebSocket();
+  const { data: media, isLoading, error } = useMediaState(initialStatus);
+  const queue = useMediaQueue();
+  const skip = useMediaSkip();
+  const stop = useMediaStop();
+  const loop = useMediaLoop();
+  useMediaWsSync(ws);
+  const ambient = useAmbient();
+
+  const [url, setUrl] = useState("");
+
+  const playing = media?.playing ?? false;
+  const current = media?.current ?? null;
+  const queueList = media?.queue ?? [];
+
+  const tone = playing ? "signal" : queueList.length ? "amber" : "signal";
+  useEffect(() => {
+    ambient.set(
+      tone,
+      playing ? 0.5 : 0.25,
+      playing ? "now playing" : "media idle",
+    );
+  }, [tone, playing, ambient]);
+
+  const onPlay = async () => {
+    const u = url.trim();
+    if (!u) {
+      toast({ title: "Enter a media URL", tone: "vermilion" });
+      return;
+    }
+    try {
+      await queue.mutateAsync({ url: u, mode: "music" });
+      setUrl("");
+      toast({ title: "Queued", tone: "signal" });
+    } catch (e) {
+      toast({
+        title: "Queue failed",
+        description: String(e),
+        tone: "vermilion",
+      });
+    }
+  };
+
+  if (error && !media) return <ErrorState error={error} />;
+  if (!media && isLoading) return <LoadingState label="Reading deck" />;
 
   return (
-    <div className="space-y-5 animate-fade-in-up">
-      <MusicPlayer ws={ws} initialData={initialStatus} />
+    <div className="space-y-5">
+      <GlassPanel glow className="relative overflow-hidden">
+        <div className="scan-line absolute inset-x-0 top-0" />
+        <div className="flex flex-col gap-5 sm:flex-row sm:items-center">
+          <div
+            className={`flex size-32 shrink-0 items-center justify-center rounded-full border border-hairline bg-gradient-to-br from-white/10 to-white/[0.02] ${playing ? "animate-spin-disc" : "animate-spin-disc paused"}`}
+          >
+            <div className="flex size-28 items-center justify-center rounded-full bg-canvas/60">
+              <ListMusic className="size-10 text-signal" />
+            </div>
+          </div>
+
+          <div className="min-w-0 flex-1">
+            <div className="eyebrow mb-1">Now playing</div>
+            <h2 className="display truncate text-2xl text-ink">
+              {current?.title ?? "Nothing queued"}
+            </h2>
+            {current?.source && (
+              <div className="mono mt-1 truncate text-xs text-ink-faint">
+                {current.source}
+              </div>
+            )}
+            <div className="mt-4 flex flex-wrap items-center gap-2">
+              <Button
+                variant="primary"
+                size="sm"
+                onClick={onPlay}
+                disabled={queue.isPending}
+              >
+                <Play className="size-4" /> Queue & play
+              </Button>
+              <Button
+                variant="outline"
+                size="sm"
+                onClick={() => skip.mutate()}
+                disabled={skip.isPending}
+              >
+                <SkipForward className="size-4" /> Skip
+              </Button>
+              <Button
+                variant="outline"
+                size="sm"
+                onClick={() => stop.mutate()}
+                disabled={stop.isPending}
+              >
+                <Square className="size-4" /> Stop
+              </Button>
+              <Button
+                variant={media?.loop ? "primary" : "outline"}
+                size="sm"
+                onClick={() => loop.mutate(!media?.loop)}
+                aria-pressed={!!media?.loop}
+              >
+                <Repeat className="size-4" /> Loop
+              </Button>
+            </div>
+          </div>
+        </div>
+
+        <div className="mt-5 flex items-center gap-2">
+          <Input
+            placeholder="Paste a YouTube / music URL…"
+            value={url}
+            onChange={(e) => setUrl(e.target.value)}
+            onKeyDown={(e) => e.key === "Enter" && onPlay()}
+          />
+        </div>
+      </GlassPanel>
+
+      <GlassPanel>
+        <SectionHeader
+          eyebrow="up next"
+          title="Queue"
+          action={
+            <span className="mono text-xs text-ink-faint">
+              {queueList.length} tracks
+            </span>
+          }
+        />
+        {queueList.length === 0 ? (
+          <div className="flex flex-col items-center gap-2 py-10 text-center">
+            <Radio className="size-6 text-ink-faint" />
+            <div className="text-sm text-ink-soft">Queue is empty</div>
+            <div className="text-xs text-ink-faint">
+              Paste a URL above to start playback.
+            </div>
+          </div>
+        ) : (
+          <div className="space-y-2">
+            {queueList.map((item, i) => (
+              <div
+                key={`${item.source}-${i}`}
+                className="flex items-center gap-3 rounded-[10px] border border-hairline bg-white/5 px-3 py-2.5"
+              >
+                <span className="mono w-5 text-ink-faint">{i + 1}</span>
+                <div className="min-w-0 flex-1">
+                  <div className="truncate text-sm text-ink">{item.title}</div>
+                  <div className="mono truncate text-[0.65rem] text-ink-faint">
+                    {item.source}
+                  </div>
+                </div>
+                <span className="pill">{item.mode ?? "music"}</span>
+              </div>
+            ))}
+          </div>
+        )}
+      </GlassPanel>
     </div>
   );
 }

services/frontend/src/app/(dashboard)/messages/page.tsx

@@ -1,41 +1,20 @@
-/**
- * Messages page — Server Component.
- *
- * Reads the URL (guild/channel/tab/selected) on the server and, when a guild
- * is already selected, fetches the first message page server-side so the
- * initial list is server-rendered, not a client round-trip.
- */
-import { getMessages, type MessagePageResult } from "@/lib/api/server";
-import MessagesView from "./view";
+import { getConfig, getGuilds } from "@/lib/api/server";
+import { MessagesView } from "./view";
 
-export default async function MessagesPage({
-  searchParams,
-}: {
-  searchParams: Promise<Record<string, string | string[] | undefined>>;
-}) {
-  const sp = await searchParams;
-  const guild = typeof sp.guild === "string" ? sp.guild : "";
-  const channel = typeof sp.channel === "string" ? sp.channel : "";
-  const selected = typeof sp.selected === "string" ? sp.selected : null;
-  const tab =
-    typeof sp.tab === "string" && ["all", "images", "review"].includes(sp.tab)
-      ? (sp.tab as "all" | "images" | "review")
-      : "all";
+export const dynamic = "force-dynamic";
 
-  let initialPage: MessagePageResult | undefined;
-  if (guild) {
-    initialPage = await getMessages(guild, channel || undefined).catch(
-      () => undefined,
-    );
+export default async function MessagesPage() {
+  let config: import("@/lib/types/guild").AppConfig | undefined;
+  let guilds: import("@/lib/types").Guild[] | undefined;
+  try {
+    [config, guilds] = await Promise.all([getConfig(), getGuilds()]);
+  } catch {
+    /* client hooks surface errors */
   }
-
   return (
     <MessagesView
-      initialGuild={guild}
-      initialChannel={channel}
-      initialDetailId={selected}
-      initialTab={tab}
-      initialMessagePage={initialPage}
+      initialGuilds={guilds}
+      initialGuildId={config?.monitorGuildId ?? null}
     />
   );
 }

services/frontend/src/app/(dashboard)/messages/view.tsx

@@ -1,369 +1,334 @@
 "use client";
 
-import { Flag, Image, Loader2, Search } from "lucide-react";
-import { useRouter } from "next/navigation";
-import { useCallback, useEffect, useState } from "react";
-import { SubNav } from "@/components/layout/sub-nav";
-import { Lightbox } from "@/components/messages/lightbox";
-import { extractFirstImage } from "@/components/messages/message-card";
-import { MessageDetailView } from "@/components/messages/message-detail-view";
-import { MessageList } from "@/components/messages/message-list";
-import { SearchOverlay } from "@/components/messages/search-overlay";
-import { EmptyState, ErrorState, LoadingSkeleton } from "@/components/shared";
-import { GuildSelector } from "@/components/shared/guild-selector";
-import { Card } from "@/components/ui/card";
 import {
-  Select,
-  SelectContent,
-  SelectItem,
-  SelectTrigger,
-  SelectValue,
-} from "@/components/ui/select";
+  AlertTriangle,
+  CheckCircle2,
+  Image as ImageIcon,
+  Loader2,
+  MessageSquare,
+  Paperclip,
+  Search,
+  ShieldAlert,
+} from "lucide-react";
+import { useEffect, useState } from "react";
+import { useAmbient } from "@/components/ambient/ambient-context";
+import {
+  Avatar,
+  Badge,
+  GlassPanel,
+  Input,
+  Skeleton,
+} from "@/components/primitives";
+import {
+  EmptyState,
+  ErrorState,
+  LoadingState,
+  SectionHeader,
+} from "@/components/shared";
+import { GuildChannelPicker } from "@/components/shared/guild-picker";
 import {
-  useImages,
-  useLoadMore,
   useMessageDetail,
+  useMessageSearch,
   useMessages,
-  useMessagesHasMore,
   useMessagesWsSync,
-  useReview,
-  useTextChannels,
 } from "@/hooks";
-import { renderMessageContent } from "@/lib/format";
-import type { MessageRecord } from "@/lib/types";
-import { cn } from "@/lib/utils";
+import {
+  formatBytes,
+  getMessageChannelLabel,
+  renderMessageContent,
+  safeParseJsonArray,
+} from "@/lib/format";
+import type { AiStatus, Guild, MessageRecord } from "@/lib/types";
 import { useWebSocket } from "@/lib/ws/context";
 
-type MessagesTab = "all" | "images" | "review";
-
-interface MessagesViewProps {
-  initialGuild?: string;
-  initialChannel?: string;
-  initialDetailId?: string | null;
-  initialTab?: MessagesTab;
-  initialMessagePage?: { data: MessageRecord[]; nextCursor: string | null };
+function relTime(ts?: number | null) {
+  if (!ts) return "";
+  const d = Date.now() - ts;
+  const m = Math.floor(d / 60000);
+  if (m < 1) return "just now";
+  if (m < 60) return `${m}m`;
+  const h = Math.floor(m / 60);
+  if (h < 24) return `${h}h`;
+  return `${Math.floor(h / 24)}d`;
 }
 
-/**
- * Messages view — hydrated on the client. Initial guild/channel/detail/tab
- * come from the URL (server-read on first SSR), and the first message page is
- * seeded from the server when a guild is already selected.
- */
-export default function MessagesView({
-  initialGuild = "",
-  initialChannel = "",
-  initialDetailId = null,
-  initialTab = "all",
-  initialMessagePage,
-}: MessagesViewProps) {
-  const router = useRouter();
-  const [guildId, setGuildId] = useState(initialGuild);
-  const [selectedChannel, setSelectedChannel] = useState(initialChannel);
-  const [detailId, setDetailId] = useState<string | null>(initialDetailId);
-  const [tab, setTab] = useState<MessagesTab>(initialTab);
-  const [searchOpen, setSearchOpen] = useState(false);
-  const [lightbox, setLightbox] = useState<{
-    images: Array<{ src: string; alt?: string }>;
-    index: number;
-  } | null>(null);
+function aiTone(
+  s?: AiStatus | null,
+): "signal" | "amber" | "vermilion" | "neutral" {
+  if (s === "clean") return "signal";
+  if (s === "warn") return "amber";
+  if (s === "flagged" || s === "error") return "vermilion";
+  if (s === "processing" || s === "pending") return "neutral";
+  return "neutral";
+}
 
+export function MessagesView({
+  initialGuilds,
+  initialGuildId,
+}: {
+  initialGuilds?: Guild[];
+  initialGuildId?: string | null;
+}) {
   const ws = useWebSocket();
-  const { data: channels = [] } = useTextChannels(guildId);
+  const [guildId, setGuildId] = useState<string | null>(
+    initialGuildId ?? initialGuilds?.[0]?.id ?? null,
+  );
+  const [channelId, setChannelId] = useState<string | null>(null);
+  const [selected, setSelected] = useState<string | null>(null);
+  const [query, setQuery] = useState("");
+
   const {
     data: messages,
+    isLoading,
     error,
-    refetch,
-  } = useMessages(
-    guildId,
-    selectedChannel || undefined,
-    guildId === initialGuild && selectedChannel === initialChannel
-      ? initialMessagePage
-      : undefined,
-  );
-  const { data: cursorData } = useMessagesHasMore(
-    guildId,
-    selectedChannel || undefined,
-  );
-  const loadMoreMut = useLoadMore();
-  const { data: images } = useImages(guildId);
-  const { data: reviews } = useReview(selectedChannel || undefined);
+  } = useMessages(guildId ?? "", channelId ?? undefined);
+  useMessagesWsSync(ws, guildId ?? "");
+  const search = useMessageSearch(query, query.trim().length >= 2);
+  const detail = useMessageDetail(selected);
+  const ambient = useAmbient();
 
-  const {
-    message: detailMessage,
-    attachments: detailAttachments,
-    loading: detailLoading,
-  } = useMessageDetail(detailId);
-
-  useMessagesWsSync(ws, guildId);
-
-  // Sync state to URL
   useEffect(() => {
-    const params = new URLSearchParams();
-    if (guildId) params.set("guild", guildId);
-    if (selectedChannel) params.set("channel", selectedChannel);
-    if (detailId) params.set("selected", detailId);
-    if (tab !== "all") params.set("tab", tab);
-    router.replace(`/messages?${params.toString()}`, { scroll: false });
-  }, [guildId, selectedChannel, detailId, tab, router]);
+    ambient.set(query ? "amber" : "signal", 0.3, query ? "search" : "messages");
+  }, [query, ambient]);
 
-  // Global Cmd+K search trigger
-  useEffect(() => {
-    const handleKey = (e: KeyboardEvent) => {
-      if ((e.metaKey || e.ctrlKey) && e.key === "k") {
-        e.preventDefault();
-        setSearchOpen(true);
-      }
-    };
-    document.addEventListener("keydown", handleKey);
-    return () => document.removeEventListener("keydown", handleKey);
-  }, []);
+  const searching = query.trim().length >= 2;
+  const list = searching ? (search.data ?? []) : (messages ?? []);
 
-  const handleLoadMore = useCallback(() => {
-    if (!cursorData?.cursor || loadMoreMut.isPending) return;
-    loadMoreMut.mutate({
-      guildId,
-      channelId: selectedChannel || undefined,
-      cursor: cursorData.cursor,
-    });
-  }, [cursorData, loadMoreMut, guildId, selectedChannel]);
-
-  const handleGuildChange = useCallback((g: string) => {
+  return (
+    <div className="space-y-4">
+      <GlassPanel className="flex flex-wrap items-center gap-3">
+        <GuildChannelPicker
+          mode="text"
+          guildsInitial={initialGuilds}
+          guildId={guildId}
+          channelId={channelId}
+          onChange={(g, c) => {
             setGuildId(g);
-    setSelectedChannel("");
-    setDetailId(null);
-  }, []);
+            setChannelId(c);
+            setSelected(null);
+          }}
+        />
+        <div className="relative ml-auto w-64">
+          <Search className="absolute left-3 top-1/2 size-4 -translate-y-1/2 text-ink-faint" />
+          <Input
+            className="pl-9"
+            placeholder="Search messages…"
+            value={query}
+            onChange={(e) => setQuery(e.target.value)}
+          />
+        </div>
+      </GlassPanel>
 
-  const subNavTabs = [
-    { id: "all", label: "All", icon: null },
-    { id: "images", label: "Images", icon: <Image className="size-3" /> },
-    { id: "review", label: "Review", icon: <Flag className="size-3" /> },
-  ];
-
-  const currentMessages = messages ?? [];
-
-  return (
-    <div className="animate-fade-in-up space-y-4">
-      {/* ── Controls bar ── */}
-      <div className="flex items-center gap-3">
-        <GuildSelector value={guildId} onChange={handleGuildChange} />
-        {channels.length > 0 && (
-          <Select
-            value={selectedChannel}
-            onValueChange={(v) => setSelectedChannel(v ?? "")}
-          >
-            <SelectTrigger className="h-9 w-48">
-              <SelectValue placeholder="All channels" />
-            </SelectTrigger>
-            <SelectContent>
-              <SelectItem value="">All channels</SelectItem>
-              {channels.map((ch) => (
-                <SelectItem key={ch.id} value={ch.id}>
-                  # {ch.name}
-                </SelectItem>
-              ))}
-            </SelectContent>
-          </Select>
-        )}
-        <button
-          type="button"
-          onClick={() => setSearchOpen(true)}
-          className="ml-auto flex items-center gap-1.5 rounded-md px-3 py-1.5 text-xs text-text-secondary/60 hover:text-text-primary glass hover:glass-elevated transition-all"
-        >
-          <Search className="size-3.5" />
-          Search
-          <span className="hidden font-mono text-[10px] text-text-secondary/30 sm:inline">
-            &#8984;K
+      <div className="grid gap-4 lg:grid-cols-5">
+        <GlassPanel className="lg:col-span-3">
+          <SectionHeader
+            eyebrow={searching ? "results" : "live feed"}
+            title={searching ? `“${query}”` : "Messages"}
+            action={
+              <span className="mono text-xs text-ink-faint">
+                {list.length} shown
               </span>
-        </button>
-      </div>
-
-      {/* ── Sub navigation ── */}
-      <SubNav
-        tabs={subNavTabs}
-        activeTab={tab}
-        onTabChange={(t) => setTab(t as MessagesTab)}
-      />
-
-      {/* ── Split pane ── */}
-      {error ? (
-        <ErrorState message={error.message} onRetry={refetch} />
-      ) : !messages ? (
-        <LoadingSkeleton count={6} height="h-20" />
-      ) : (
-        <div className="flex gap-4">
-          {/* Left pane */}
-          <div
-            className={cn("space-y-2", detailId ? "w-1/2 lg:w-2/5" : "w-full")}
-          >
-            {tab === "all" && (
-              <MessageList
-                messages={currentMessages}
-                selectedId={detailId}
-                onSelect={setDetailId}
-                hasMore={cursorData?.hasMore}
-                onLoadMore={handleLoadMore}
-                isLoadingMore={loadMoreMut.isPending}
-              />
-            )}
-            {tab === "images" && (
-              <ImageGrid items={images ?? []} onSelect={setDetailId} />
-            )}
-            {tab === "review" && (
-              <ReviewList items={reviews ?? []} onSelect={setDetailId} />
-            )}
-          </div>
-
-          {/* Right pane — message detail */}
-          {detailId && (
-            <div className="sticky top-16 hidden w-1/2 self-start md:block lg:w-3/5">
-              {detailLoading ? (
-                <Card
-                  className={cn(
-                    "flex items-center justify-center py-12",
-                    "[--card-spacing:0px]",
-                  )}
-                >
-                  <Loader2 className="size-5 animate-spin text-text-secondary/60" />
-                </Card>
-              ) : detailMessage ? (
-                <div className="space-y-3">
-                  <button
-                    type="button"
-                    onClick={() => setDetailId(null)}
-                    className="text-xs text-text-secondary/60 hover:text-text-primary transition-colors"
-                  >
-                    &larr; Back to list
-                  </button>
-                  <MessageDetailView
-                    message={detailMessage}
-                    attachments={detailAttachments}
-                    onImageClick={(index) => {
-                      const imgs = (detailAttachments ?? [])
-                        .filter((a) => a.type?.startsWith("image/"))
-                        .map((a) => ({
-                          src: a.uploaded_url || a.discord_url,
-                          alt: a.filename,
-                        }));
-                      if (imgs.length > 0) {
-                        setLightbox({ images: imgs, index });
             }
-                    }}
           />
-                </div>
-              ) : null}
-            </div>
-          )}
-        </div>
-      )}
-
-      {/* ── Search overlay ── */}
-      <SearchOverlay
-        open={searchOpen}
-        onClose={() => setSearchOpen(false)}
-        onSelect={(id) => {
-          setDetailId(id);
-          setTab("all");
-        }}
-      />
-
-      {/* ── Lightbox ── */}
-      {lightbox && (
-        <Lightbox
-          images={lightbox.images}
-          initialIndex={lightbox.index}
-          open
-          onClose={() => setLightbox(null)}
-        />
-      )}
-    </div>
-  );
-}
-
-// ── Inline ImageGrid (glass-styled) ────────────────
-
-function ImageGrid({
-  items,
-  onSelect,
-}: {
-  items: MessageRecord[];
-  onSelect: (id: string) => void;
-}) {
-  return (
-    <div className="grid grid-cols-3 gap-2">
-      {items.map((item) => {
-        const imgUrl = extractFirstImage(item.metadata);
-        return (
-          <button
-            key={item.id}
-            type="button"
-            onClick={() => onSelect(item.id)}
-            className="glass overflow-hidden rounded-lg transition-transform hover:scale-[1.02]"
-          >
-            {imgUrl ? (
-              <img
-                src={imgUrl}
-                alt=""
-                className="h-24 w-full object-cover"
-                loading="lazy"
+          {error && !messages ? (
+            <ErrorState error={error} />
+          ) : isLoading && !messages ? (
+            <LoadingState label="Capturing" />
+          ) : list.length === 0 ? (
+            <EmptyState
+              icon={<MessageSquare className="size-7" />}
+              title="No messages"
+              description="Pick a guild to begin, or run a search."
             />
           ) : (
-              <div className="flex h-24 w-full items-center justify-center text-xs text-text-secondary/40">
-                No image
-              </div>
-            )}
-          </button>
-        );
-      })}
-      {items.length === 0 && (
-        <EmptyState
-          icon={Image}
-          title="No images"
-          description="Messages with image attachments will show up here."
-          className="col-span-3"
-        />
-      )}
-    </div>
-  );
-}
-
-// ── Inline ReviewList (glass-styled) ────────────────
-
-function ReviewList({
-  items,
-  onSelect,
-}: {
-  items: MessageRecord[];
-  onSelect: (id: string) => void;
-}) {
-  return (
-    <div className="space-y-2">
-      {items.map((item) => (
-        <Card
-          key={item.id}
-          className={cn(
-            "cursor-pointer p-3",
-            "border border-red-500/30 ring-red-500/20",
-            "[--card-spacing:0px]",
-            "rounded-2xl",
-          )}
-          onClick={() => onSelect(item.id)}
+            <div className="max-h-[60vh] space-y-1.5 overflow-y-auto pr-1">
+              {list.map((m) => (
+                <button
+                  key={m.id}
+                  type="button"
+                  onClick={() => setSelected(m.id)}
+                  className={`flex w-full items-start gap-3 rounded-[12px] border p-3 text-left transition-colors ${
+                    selected === m.id
+                      ? "border-signal/40 bg-signal/8"
+                      : "border-hairline bg-white/[0.03] hover:bg-white/[0.06]"
+                  }`}
                 >
-          <div className="flex items-start gap-2">
-            <Flag className="mt-0.5 size-3.5 shrink-0 text-accent-purple" />
+                  <Avatar src={m.avatar_url} name={m.username} size={34} />
                   <div className="min-w-0 flex-1">
-              <p className="line-clamp-2 text-xs text-text-secondary">
-                {renderMessageContent(item.content, item.metadata) || item.id}
-              </p>
+                    <div className="flex items-center gap-2">
+                      <span className="truncate text-sm font-semibold text-ink">
+                        {m.username}
+                      </span>
+                      <span className="mono text-[0.65rem] text-ink-faint">
+                        {getMessageChannelLabel(m)}
+                      </span>
+                      <span className="mono ml-auto text-[0.6rem] text-ink-faint">
+                        {relTime(m.created_at)}
+                      </span>
+                    </div>
+                    <div className="mt-0.5 line-clamp-2 text-sm text-ink-soft">
+                      {renderMessageContent(m.content, m.metadata) || (
+                        <span className="italic text-ink-faint">
+                          (empty / embed)
+                        </span>
+                      )}
                     </div>
                   </div>
-        </Card>
-      ))}
-      {items.length === 0 && (
-        <EmptyState
-          icon={Flag}
-          title="No flagged messages"
-          description="Messages flagged by AI moderation will appear here for review."
+                  <AiBadge
+                    status={m.ai_status}
+                    durationMs={m.ai_analysis_duration_ms}
                   />
+                </button>
+              ))}
+            </div>
+          )}
+        </GlassPanel>
+
+        <GlassPanel className="lg:col-span-2">
+          <SectionHeader eyebrow="inspect" title="Detail" />
+          {!selected ? (
+            <EmptyState
+              title="Select a message"
+              description="Click any message to inspect AI analysis, attachments and edit history."
+            />
+          ) : detail.loading ? (
+            <div className="space-y-2">
+              <Skeleton className="h-20" />
+              <Skeleton className="h-12" />
+            </div>
+          ) : detail.message ? (
+            <MessageDetail
+              m={detail.message}
+              attachments={detail.attachments}
+            />
+          ) : (
+            <EmptyState title="Not found" />
+          )}
+        </GlassPanel>
+      </div>
+    </div>
+  );
+}
+
+function AiBadge({
+  status,
+  durationMs,
+}: {
+  status?: AiStatus | null;
+  durationMs?: number | null;
+}) {
+  if (!status) return null;
+  const tone = aiTone(status);
+  const icon =
+    status === "clean" ? (
+      <CheckCircle2 className="size-3" />
+    ) : status === "flagged" ? (
+      <ShieldAlert className="size-3" />
+    ) : status === "warn" ? (
+      <AlertTriangle className="size-3" />
+    ) : status === "processing" || status === "pending" ? (
+      <Loader2 className="size-3 animate-spin" />
+    ) : (
+      <AlertTriangle className="size-3" />
+    );
+  const label =
+    durationMs && durationMs > 0
+      ? `${status} · ${formatDuration(durationMs)}`
+      : status;
+
+  return (
+    <Badge tone={tone} dot={status === "processing" || status === "pending"}>
+      {icon}
+      {label}
+    </Badge>
+  );
+}
+
+/** Human-readable analysis duration, e.g. 850ms / 1.2s / 3.4s. */
+function formatDuration(ms: number): string {
+  if (ms < 1000) return `${Math.round(ms)}ms`;
+  return `${(ms / 1000).toFixed(1)}s`;
+}
+
+function MessageDetail({
+  m,
+  attachments,
+}: {
+  m: MessageRecord;
+  attachments: import("@/lib/types").AttachmentRecord[];
+}) {
+  const flags = safeParseJsonArray(m.ai_moderation_flags);
+  const cats = safeParseJsonArray(m.ai_categories);
+  return (
+    <div className="space-y-3 text-sm">
+      <div className="flex items-center gap-3">
+        <Avatar src={m.avatar_url} name={m.username} size={40} />
+        <div>
+          <div className="font-semibold text-ink">{m.username}</div>
+          <div className="mono text-[0.65rem] text-ink-faint">
+            {getMessageChannelLabel(m)} · {relTime(m.created_at)}
+          </div>
+        </div>
+        <div className="ml-auto">
+          <AiBadge
+            status={m.ai_status}
+            durationMs={m.ai_analysis_duration_ms}
+          />
+        </div>
+      </div>
+
+      <div className="rounded-[10px] border border-hairline bg-white/[0.03] p-3 text-ink-soft">
+        {renderMessageContent(m.edited_content ?? m.content, m.metadata) ||
+          "(no text)"}
+      </div>
+
+      {m.ai_analysis && (
+        <div>
+          <div className="eyebrow mb-1">AI analysis</div>
+          <div className="rounded-[10px] border border-hairline bg-white/[0.03] p-3 text-ink-soft">
+            {m.ai_analysis}
+          </div>
+        </div>
+      )}
+
+      {(flags.length > 0 || cats.length > 0) && (
+        <div className="flex flex-wrap gap-1.5">
+          {flags.map((f) => (
+            <Badge key={f} tone="vermilion">
+              {f}
+            </Badge>
+          ))}
+          {cats.map((c) => (
+            <Badge key={c} tone="amber">
+              {c}
+            </Badge>
+          ))}
+        </div>
+      )}
+
+      {attachments.length > 0 && (
+        <div>
+          <div className="eyebrow mb-1 flex items-center gap-1.5">
+            <Paperclip className="size-3" /> Attachments ({attachments.length})
+          </div>
+          <div className="space-y-1.5">
+            {attachments.map((a) => (
+              <a
+                key={a.id}
+                href={a.discord_url ?? a.uploaded_url ?? "#"}
+                target="_blank"
+                rel="noreferrer"
+                className="flex items-center gap-2 rounded-[10px] border border-hairline bg-white/5 px-3 py-2 text-xs text-ink-soft hover:text-ink"
+              >
+                <ImageIcon className="size-3.5 text-signal" />
+                <span className="flex-1 truncate">{a.filename}</span>
+                <span className="mono text-ink-faint">
+                  {formatBytes(a.size)}
+                </span>
+              </a>
+            ))}
+          </div>
+        </div>
       )}
     </div>
   );

services/frontend/src/app/(dashboard)/moderation/page.tsx

@@ -1,24 +1,18 @@
-/**
- * Moderation page — Server Component. Seeds summary + action log from
- * server-fetched moderation state (shared across all users).
- */
-import { ModerationSection } from "@/components/moderation/moderation-section";
 import { getModerationActions, getModerationStats } from "@/lib/api/server";
+import { ModerationView } from "./view";
+
+export const dynamic = "force-dynamic";
 
 export default async function ModerationPage() {
-  const [stats, actions] = await Promise.allSettled([
+  let stats: import("@/lib/types").ModerationStats | undefined;
+  let actions: import("@/lib/types").ModerationAction[] | undefined;
+  try {
+    [stats, actions] = await Promise.all([
       getModerationStats(),
       getModerationActions(100),
     ]);
-
-  return (
-    <div className="space-y-4 animate-fade-in-up">
-      <ModerationSection
-        initialStats={stats.status === "fulfilled" ? stats.value : undefined}
-        initialActions={
-          actions.status === "fulfilled" ? actions.value : undefined
+  } catch {
+    /* client hooks surface errors */
   }
-      />
-    </div>
-  );
+  return <ModerationView initialStats={stats} initialActions={actions} />;
 }

services/frontend/src/app/(dashboard)/moderation/view.tsx

@@ -0,0 +1,267 @@
+"use client";
+
+import {
+  AlertTriangle,
+  Ban,
+  CheckCircle2,
+  Clock,
+  Filter,
+  MessageSquareWarning,
+  MicOff,
+  ShieldAlert,
+  Trash2,
+  UserX,
+  XCircle,
+} from "lucide-react";
+import { useEffect, useState } from "react";
+import { useAmbient } from "@/components/ambient/ambient-context";
+import { Donut } from "@/components/charts";
+import {
+  Badge,
+  GlassPanel,
+  Select,
+  type SelectOption,
+} from "@/components/primitives";
+import {
+  ErrorState,
+  LoadingState,
+  MetricTile,
+  SectionHeader,
+} from "@/components/shared";
+import { useModerationActions, useModerationStats } from "@/hooks";
+import { formatNumber } from "@/lib/format";
+import type {
+  ModerationAction,
+  ModerationActionType,
+  ModerationStats,
+} from "@/lib/types";
+
+const ACTION_ICON: Record<ModerationActionType, React.ReactNode> = {
+  delete_message: <Trash2 className="size-3.5" />,
+  mute_user: <MicOff className="size-3.5" />,
+  warn_user: <MessageSquareWarning className="size-3.5" />,
+  kick_user: <UserX className="size-3.5" />,
+  ban_user: <Ban className="size-3.5" />,
+};
+
+const ACTION_LABEL: Record<ModerationActionType, string> = {
+  delete_message: "Delete",
+  mute_user: "Mute",
+  warn_user: "Warn",
+  kick_user: "Kick",
+  ban_user: "Ban",
+};
+
+export function ModerationView({
+  initialStats,
+  initialActions,
+}: {
+  initialStats?: ModerationStats;
+  initialActions?: ModerationAction[];
+}) {
+  const { data: stats, isLoading, error } = useModerationStats(initialStats);
+  const [statusFilter, setStatusFilter] = useState<string>("");
+  const [typeFilter, setTypeFilter] = useState<string>("");
+  const { data: actions } = useModerationActions(
+    statusFilter || undefined,
+    typeFilter || undefined,
+    !statusFilter && !typeFilter ? initialActions : undefined,
+  );
+
+  const failedRate = stats ? stats.failed_rate * 100 : 0;
+
+  const byAction = stats?.by_action ?? {};
+  const segments = Object.entries(byAction).map(([k, _v]) => ({
+    value: 1,
+    color:
+      k === "ban_user" || k === "kick_user"
+        ? "var(--color-vermilion)"
+        : k === "warn_user"
+          ? "var(--color-amber)"
+          : "var(--color-signal)",
+    label: k,
+  }));
+
+  const ambient = useAmbient();
+  useEffect(() => {
+    ambient.set(
+      failedRate > 20 ? "vermilion" : failedRate > 5 ? "amber" : "signal",
+      0.3 + Math.min(0.4, failedRate / 50),
+      "moderation",
+    );
+  }, [failedRate, ambient]);
+
+  if (error && !stats) return <ErrorState error={error} />;
+  if (!stats && isLoading) return <LoadingState label="Reading log" />;
+  if (!stats) return <ErrorState error={error ?? new Error("No data")} />;
+
+  const statusOpts: SelectOption[] = [
+    { value: "", label: "All statuses" },
+    { value: "pending", label: "Pending" },
+    { value: "executed", label: "Executed" },
+    { value: "failed", label: "Failed" },
+  ];
+  const typeOpts: SelectOption[] = [
+    { value: "", label: "All actions" },
+    ...Object.keys(byAction).map((k) => ({
+      value: k,
+      label: ACTION_LABEL[k as ModerationActionType] ?? k,
+    })),
+  ];
+
+  return (
+    <div className="space-y-5">
+      <div className="grid grid-cols-2 gap-3 md:grid-cols-4">
+        <MetricTile
+          label="Total actions"
+          value={formatNumber(stats.total)}
+          tone="signal"
+          icon={<ShieldAlert className="size-3.5" />}
+        />
+        <MetricTile
+          label="Executed"
+          value={formatNumber(stats.executed)}
+          tone="signal"
+          icon={<CheckCircle2 className="size-3.5" />}
+        />
+        <MetricTile
+          label="Failed"
+          value={formatNumber(stats.failed)}
+          tone={stats.failed > 0 ? "vermilion" : "neutral"}
+          icon={<XCircle className="size-3.5" />}
+        />
+        <MetricTile
+          label="Pending"
+          value={formatNumber(stats?.pending)}
+          tone={stats?.pending > 0 ? "amber" : "neutral"}
+          icon={<Clock className="size-3.5" />}
+        />
+      </div>
+
+      <div className="grid gap-5 lg:grid-cols-5">
+        <GlassPanel className="lg:col-span-2">
+          <SectionHeader eyebrow="health" title="Breakdown" />
+          <div className="flex items-center gap-5">
+            <Donut
+              segments={
+                segments.length
+                  ? segments
+                  : [
+                      {
+                        value: 1,
+                        color: "var(--color-ink-faint)",
+                        label: "none",
+                      },
+                    ]
+              }
+              centerLabel={`${Math.round(failedRate)}%`}
+              centerSub="fail rate"
+            />
+            <div className="flex-1 space-y-2 text-sm">
+              {Object.entries(byAction).map(([k, v]) => {
+                const count = typeof v === "number" ? v : null;
+                return (
+                  <div key={k} className="flex items-center gap-2.5">
+                    <span className="text-ink-soft">
+                      {ACTION_ICON[k as ModerationActionType]}
+                    </span>
+                    <span className="flex-1 text-ink-soft">
+                      {ACTION_LABEL[k as ModerationActionType] ?? k}
+                    </span>
+                    {count !== null && (
+                      <span className="mono text-ink">{count}</span>
+                    )}
+                  </div>
+                );
+              })}
+              {Object.keys(byAction).length === 0 && (
+                <div className="text-xs text-ink-faint">
+                  No actions recorded yet.
+                </div>
+              )}
+            </div>
+          </div>
+        </GlassPanel>
+
+        <GlassPanel className="lg:col-span-3">
+          <SectionHeader
+            eyebrow="filter"
+            title="Action log"
+            action={
+              <div className="flex items-center gap-2">
+                <Filter className="size-3.5 text-ink-faint" />
+                <Select
+                  value={typeFilter}
+                  onChange={setTypeFilter}
+                  options={typeOpts}
+                  size="sm"
+                  className="w-36"
+                />
+                <Select
+                  value={statusFilter}
+                  onChange={setStatusFilter}
+                  options={statusOpts}
+                  size="sm"
+                  className="w-32"
+                />
+              </div>
+            }
+          />
+          <div className="max-h-[60vh] space-y-1.5 overflow-y-auto pr-1">
+            {(actions ?? []).map((a) => (
+              <ActionRow key={a.id} a={a} />
+            ))}
+            {(actions ?? []).length === 0 && (
+              <div className="py-10 text-center text-xs text-ink-faint">
+                No matching actions.
+              </div>
+            )}
+          </div>
+        </GlassPanel>
+      </div>
+    </div>
+  );
+}
+
+function ActionRow({ a }: { a: ModerationAction }) {
+  const tone =
+    a.status === "executed"
+      ? "signal"
+      : a.status === "failed"
+        ? "vermilion"
+        : "amber";
+  const icon = ACTION_ICON[a.action_type] ?? (
+    <AlertTriangle className="size-3.5" />
+  );
+  return (
+    <div className="flex items-start gap-3 rounded-[10px] border border-hairline bg-white/[0.03] p-3">
+      <span
+        className={`mt-0.5 ${tone === "vermilion" ? "text-vermilion" : tone === "amber" ? "text-amber" : "text-signal"}`}
+      >
+        {icon}
+      </span>
+      <div className="min-w-0 flex-1">
+        <div className="flex items-center gap-2">
+          <span className="text-sm font-semibold text-ink">
+            {a.username ?? "unknown"}
+          </span>
+          <Badge tone={tone}>{a.status}</Badge>
+          <span className="mono ml-auto text-[0.6rem] text-ink-faint">
+            {a.created_at ? new Date(a.created_at).toLocaleString() : "—"}
+          </span>
+        </div>
+        {a.reason && (
+          <div className="mt-0.5 text-xs text-ink-soft">“{a.reason}”</div>
+        )}
+        {a.content && (
+          <div className="mt-1 line-clamp-2 rounded-[8px] bg-white/[0.03] px-2 py-1 text-xs text-ink-faint">
+            {a.content}
+          </div>
+        )}
+        {a.error && (
+          <div className="mt-1 text-xs text-vermilion">{a.error}</div>
+        )}
+      </div>
+    </div>
+  );
+}

services/frontend/src/app/(dashboard)/recordings/page.tsx

@@ -1,12 +1,16 @@
-/**
- * Recordings page — Server Component. Seeds the library from server-fetched
- * recordings; live `voice_recording_uploaded` events keep it fresh over WS.
- */
 import { getRecordings } from "@/lib/api/server";
-import RecordingsView from "./view";
+import { RecordingsView } from "./view";
+
+export const dynamic = "force-dynamic";
 
 export default async function RecordingsPage() {
-  const data = await getRecordings(50).catch(() => undefined);
-
-  return <RecordingsView initialRecordings={data?.items} />;
+  let recordings:
+    | import("@/lib/types/recording").PaginatedRecordings
+    | undefined;
+  try {
+    recordings = await getRecordings(50);
+  } catch {
+    /* client hooks surface errors */
+  }
+  return <RecordingsView initialItems={recordings?.items} />;
 }

services/frontend/src/app/(dashboard)/recordings/view.tsx

@@ -1,189 +1,138 @@
 "use client";
 
-import { Clock, Database, Mic, Users } from "lucide-react";
-import { useMemo, useRef, useState } from "react";
-import { StatCard } from "@/components/dashboard/stat-card";
-import { SubNav } from "@/components/layout/sub-nav";
-import { RecordingCard } from "@/components/recordings/recording-card";
-import { RecordingPlayer } from "@/components/recordings/recording-player";
-import { EmptyState, ErrorState, LoadingSkeleton } from "@/components/shared";
-import { useRecordings, useRecordingsWsSync } from "@/hooks";
+import { Download, Headphones, Trash2 } from "lucide-react";
+import { useEffect } from "react";
+import { useAmbient } from "@/components/ambient/ambient-context";
+import {
+  Avatar,
+  Button,
+  GlassCard,
+  GlassPanel,
+  toast,
+} from "@/components/primitives";
+import {
+  EmptyState,
+  ErrorState,
+  LoadingState,
+  SectionHeader,
+} from "@/components/shared";
+import {
+  useDeleteRecording,
+  useRecordings,
+  useRecordingsWsSync,
+} from "@/hooks";
 import { formatBytes } from "@/lib/format";
 import type { VoiceRecording } from "@/lib/types";
 import { useWebSocket } from "@/lib/ws/context";
 
-type RecordingsTab = "library" | "stats";
-
-export default function RecordingsView({
-  initialRecordings,
+export function RecordingsView({
+  initialItems,
 }: {
-  initialRecordings?: VoiceRecording[];
+  initialItems?: VoiceRecording[];
 }) {
-  const {
-    data: recordings,
-    error,
-    mutate: refetch,
-  } = useRecordings(initialRecordings);
-  const [playingId, setPlayingId] = useState<string | null>(null);
-  const [isPlaying, setIsPlaying] = useState(false);
-  const [isLoadingAudio, setIsLoadingAudio] = useState(false);
-  const [tab, setTab] = useState<RecordingsTab>("library");
   const ws = useWebSocket();
-  const audioRef = useRef<HTMLAudioElement | null>(null);
-
-  // Live-update the library when the gateway publishes voice_recording_uploaded
+  const { data: items, isLoading, error } = useRecordings(initialItems);
+  const del = useDeleteRecording();
   useRecordingsWsSync(ws);
+  const ambient = useAmbient();
 
-  const currentTrack =
-    playingId && recordings
-      ? recordings.find((r: VoiceRecording) => r.id === playingId)
-      : null;
+  useEffect(() => {
+    ambient.set("signal", 0.3, "recordings");
+  }, [ambient]);
 
-  const togglePlay = (id: string) => {
-    if (playingId !== id) {
-      setPlayingId(id); // RecordingPlayer picks up the new url + autoplays
-    } else {
-      const audio = audioRef.current;
-      if (!audio) return;
-      if (audio.paused) audio.play().catch(() => {});
-      else audio.pause();
+  const onDelete = async (id: string) => {
+    try {
+      await del.mutateAsync(id);
+      toast({ title: "Recording deleted", tone: "signal" });
+    } catch (e) {
+      toast({
+        title: "Delete failed",
+        description: String(e),
+        tone: "vermilion",
+      });
     }
   };
 
-  const stats = useMemo(() => {
-    const list = recordings ?? [];
-    const totalSize = list.reduce((sum, r) => sum + (r.size_bytes ?? 0), 0);
-    const byUser = new Map<
-      string,
-      { name: string; count: number; size: number }
-    >();
-    for (const rec of list) {
-      const key = rec.user_id ?? rec.username;
-      const cur = byUser.get(key) ?? { name: rec.username, count: 0, size: 0 };
-      cur.count += 1;
-      cur.size += rec.size_bytes ?? 0;
-      byUser.set(key, cur);
-    }
-    const topUsers = [...byUser.values()]
-      .sort((a, b) => b.count - a.count)
-      .slice(0, 8);
-    return {
-      total: list.length,
-      totalSize,
-      uniqueUsers: byUser.size,
-      topUsers,
-    };
-  }, [recordings]);
+  if (error && !items) return <ErrorState error={error} />;
+  if (!items && isLoading) return <LoadingState label="Loading clips" />;
 
   return (
-    <div className="space-y-4 animate-fade-in-up">
-      <SubNav
-        tabs={[
-          { id: "library", label: "Library", icon: undefined },
-          { id: "stats", label: "Stats", icon: undefined },
-        ]}
-        activeTab={tab}
-        onTabChange={(t) => setTab(t as RecordingsTab)}
+    <GlassPanel>
+      <SectionHeader
+        eyebrow="voice captures"
+        title="Recordings"
+        action={
+          <span className="mono text-xs text-ink-faint">
+            {(items ?? []).length} clips
+          </span>
+        }
       />
-
-      {tab === "library" &&
-        (error ? (
-          <ErrorState message={error.message} onRetry={refetch} />
-        ) : !recordings ? (
-          <LoadingSkeleton count={4} height="h-28" />
-        ) : (
-          <div className="space-y-2">
-            {(recordings ?? []).map((rec: VoiceRecording) => (
-              <RecordingCard
-                key={rec.id}
-                recording={rec}
-                active={playingId === rec.id}
-                playing={playingId === rec.id && isPlaying}
-                loading={playingId === rec.id && isLoadingAudio}
-                onTogglePlay={togglePlay}
-              />
-            ))}
-            {(recordings ?? []).length === 0 && (
+      {(items ?? []).length === 0 ? (
         <EmptyState
-                icon={Mic}
-                title="No records yet"
-                description="Voice recordings will appear here once members speak in a monitored voice channel."
+          icon={<Headphones className="size-7" />}
+          title="No recordings"
+          description="Voice clips captured by the bot appear here."
         />
+      ) : (
+        <div className="grid gap-3 sm:grid-cols-2 xl:grid-cols-3">
+          {(items ?? []).map((r) => (
+            <GlassCard key={r.id} className="flex flex-col gap-3">
+              <div className="flex items-center gap-3">
+                <Avatar src={r.avatar_url} name={r.username} size={38} />
+                <div className="min-w-0 flex-1">
+                  <div className="truncate text-sm font-semibold text-ink">
+                    {r.username}
+                  </div>
+                  <div className="mono text-[0.65rem] text-ink-faint">
+                    {r.channel_name ?? "voice"} ·{" "}
+                    {new Date(r.created_at).toLocaleString()}
+                  </div>
+                </div>
+                <span className="mono text-[0.65rem] text-ink-faint">
+                  {formatBytes(r.size_bytes)}
+                </span>
+              </div>
+
+              {r.download_url ? (
+                // eslint-disable-next-line jsx-a11y/media-has-caption
+                <audio
+                  controls
+                  src={r.download_url}
+                  className="h-9 w-full"
+                  preload="none"
+                  aria-label={`Voice recording ${r.id}`}
+                />
+              ) : (
+                <div className="rounded-[10px] border border-hairline bg-white/5 px-3 py-2 text-xs text-ink-faint">
+                  Upload pending…
+                </div>
               )}
-          </div>
-        ))}
 
-      {tab === "stats" &&
-        (!recordings ? (
-          <LoadingSkeleton count={4} height="h-28" columns={3} />
-        ) : stats.total === 0 ? (
-          <EmptyState
-            icon={Clock}
-            title="No recording stats yet"
-            description="Recordings are captured from monitored voice channels."
-          />
-        ) : (
-          <div className="space-y-4">
-            <div className="grid grid-cols-1 sm:grid-cols-3 gap-3">
-              <StatCard
-                label="Total Recordings"
-                value={stats.total}
-                icon={Mic}
-              />
-              <StatCard
-                label="Total Size"
-                value={stats.totalSize}
-                icon={Database}
-                formatter={(v) => formatBytes(v)}
-              />
-              <StatCard
-                label="Unique Speakers"
-                value={stats.uniqueUsers}
-                icon={Users}
-              />
-            </div>
-
-            {stats.topUsers.length > 0 && (
-              <div className="space-y-1.5">
-                <p className="text-xs text-text-secondary font-medium uppercase tracking-wide">
-                  Top Speakers
-                </p>
-                <div className="grid grid-cols-1 sm:grid-cols-2 gap-2">
-                  {stats.topUsers.map((u) => (
-                    <div
-                      key={u.name}
-                      className="flex items-center gap-3 rounded-lg border border-border/40 bg-card/40 px-3 py-2"
+              <div className="flex items-center gap-2">
+                {r.download_url && (
+                  <a
+                    href={r.download_url}
+                    target="_blank"
+                    rel="noreferrer"
+                    className="inline-flex items-center gap-1.5 rounded-[9px] border border-hairline px-2.5 py-1.5 text-xs text-ink-soft hover:text-ink hover:border-signal/40"
                   >
-                      <span className="flex size-7 items-center justify-center rounded-md bg-primary/10 font-mono text-xs text-primary">
-                        {u.count}
-                      </span>
-                      <span className="flex-1 min-w-0 truncate text-sm text-text-primary">
-                        {u.name}
-                      </span>
-                      <span className="text-[10px] font-mono text-text-secondary/50">
-                        {formatBytes(u.size)}
-                      </span>
+                    <Download className="size-3.5" /> Download
+                  </a>
+                )}
+                <Button
+                  variant="outline"
+                  size="sm"
+                  className="ml-auto"
+                  onClick={() => onDelete(r.id)}
+                  disabled={del.isPending}
+                >
+                  <Trash2 className="size-3.5" /> Delete
+                </Button>
               </div>
+            </GlassCard>
           ))}
         </div>
-              </div>
       )}
-          </div>
-        ))}
-
-      <RecordingPlayer
-        url={currentTrack?.download_url ?? undefined}
-        filename={currentTrack?.filename ?? undefined}
-        playing={isPlaying}
-        loading={isLoadingAudio}
-        audioRef={audioRef}
-        onToggle={() => togglePlay(playingId!)}
-        onStateChange={(s) => {
-          setIsPlaying(s.playing);
-          setIsLoadingAudio(s.loading);
-        }}
-        onClose={() => setPlayingId(null)}
-      />
-    </div>
+    </GlassPanel>
   );
 }

services/frontend/src/app/(dashboard)/voice/page.tsx

@@ -1,23 +1,15 @@
-/**
- * Voice page — Server Component.
- *
- * Fetches the authoritative voice connection status + guild list on the server
- * so the first paint reflects the shared gateway voice state (which channel is
- * joined, across ALL users), independent of any single browser's WS history.
- */
 import { getGuilds, getVoiceStatus } from "@/lib/api/server";
-import VoiceView from "./view";
+import { VoiceView } from "./view";
+
+export const dynamic = "force-dynamic";
 
 export default async function VoicePage() {
-  const [status, guilds] = await Promise.allSettled([
-    getVoiceStatus(),
-    getGuilds(),
-  ]);
-
-  return (
-    <VoiceView
-      initialStatus={status.status === "fulfilled" ? status.value : undefined}
-      initialGuilds={guilds.status === "fulfilled" ? guilds.value : undefined}
-    />
-  );
+  let status: import("@/lib/types").VoiceStatus | undefined;
+  let guilds: import("@/lib/types").Guild[] | undefined;
+  try {
+    [status, guilds] = await Promise.all([getVoiceStatus(), getGuilds()]);
+  } catch {
+    /* client hooks surface errors */
+  }
+  return <VoiceView initialStatus={status} initialGuilds={guilds} />;
 }