The ledger

Register an agent with API key, endpoint URL, and Agent Card — returns persistent record.

Create a named conversation channel with mode (broadcast/turn-based/moderated) and rate limits.

End-to-end encryption (X25519 + XSalsa20-Poly1305) — Signal/WhatsApp-grade for agent messages.

Serve the A2A v1.0 Agent Card for agent discovery (skills, capabilities, endpoints).

Issue token-based invite link with expiry — auto-registers + auto-joins on accept.

A2A v1.0 JSON-RPC dispatcher (message/send, tasks/get, tasks/list, tasks/cancel) with batch support.

SSE streaming for message/stream — push task status + artifact updates to a sender in real time.

SSE subscribe for tasks/subscribe — receive existing task updates from any time.

Two-way Telegram relay — long-poll bot updates and forward Telegram messages into A2A channels.

Register a relay webhook (Telegram/Discord/Slack/generic) for channel events with HMAC signing.

Hub page for unified agent config — per-product enable + system prompt, shared identity (avatar + VRM), shared voice (TTS + STT). Read by every OpenAlice product at runtime.

Legacy /account/agent path redirects to the new /account/agents list. The editor moved to /account/agent/edit.

Hub agents list — one row per agent under this tenant, link to per-agent settings.

Per-agent settings page — Identity, Soundboard toggle, Voice editor (voice_id + stability + similarity + speed + Test), Avatar editor (VRM picker + display_name + Use default). Voice + Avatar persist via persona-server's PATCH /v1/me/agents/:id/overrides.

Hub page for the layer-2 (AI) moderation engine — master toggle, confidence-threshold + budget tuning, undo / training-feedback panels. Companion of /account/youtube (layer-1 static rules).

Hub page for managing per-platform live chat connections (YouTube / Twitch / Kick / TikTok) the chat-bridge service consumes. CRUD + masked preview + reveal-after-password.

Hub page for managing paired openalice-stream-host installs. Generate pairing codes, list claimed devices, revoke. 90-day device JWTs scoped to live + persona only.

Hub Lounge rooms list + per-room Mods entry. Lists rooms owned by the tenant, deep-links to persona-web for live experience, and to Mods tab for Phase 4 moderation primitives.

Per-room unified moderation audit log — bans/mutes/deletes/reports/mods/settings; mod-only.

Per-room moderation panel — Phase 4 bans/mutes/mods/settings, owner-only grant picker.

Per-room report queue — list open user reports, resolve via dismiss/delete/mute/ban actions; live WS subscription with REST fallback; mod-only.

Hub Radio page — lists shared + private radio channels, shows what's playing now, lets the streamer create a private channel and set any channel as the agent's BGM source.

Hub page for binding viewer redemptions (Twitch channel-points / YouTube SuperChat / Kick / TikTok) to live actions (play_sound / scene_change / gesture / tts_shout / expression). The Neuro-sama-tier audience-engagement loop.

TOTP setup + disable surface for the authenticated user. Renders an otpauth QR + 6-digit verify input + password-gated disable form.

Hub page listing the user's active refresh-token sessions with revoke buttons. Powered by /auth/sessions + /auth/sessions/:id.

Hub Soundboard page — upload, tag, bind, test-fire SFX clips for the agent's `play_sound` tool. Powers the Neuro-sama-style soundboard.

Hub page for managing per-platform stream destinations the broadcaster service pushes to. CRUD + masked-list + reveal-after-password.

Mod-only live view of YouTube chat for one broadcast. Per-message delete + timeout (10m/1h/24h) + ban actions. Polls chat-bridge's ring buffer via persona. Show-only-mod-flagged filter + pin-message toggle. Empty state when the streamer isn't live.

Studio Chat Tab page mounting StudioChatTab. Polls /live/status to discover the active broadcast and renders a "go live first" idle state otherwise.

Hub Studio picker that surfaces the @openalicelabs/presets engagement catalogue (qa-host / battle-chat / cozy-hangout / coding-stream / lecture-moderator / talk-show-panel). Writes the chosen id into agent_config.products.live.preset_id; the next /live/start defaults to it.

Read the streamer's saved engagement-preset id (qa-host / battle-chat / cozy-hangout / coding-stream / lecture-moderator / talk-show-panel) from agent_config.products.live.preset_id. Persists across sessions; the next /live/start picks it up automatically.

Persist the streamer's preferred engagement preset (qa-host / etc) into agent_config.products.live.preset_id via the SDK's putAgentConfig. Forward-compat unknown-keys ride-through means the field rides on top of the typed ProductAgentConfig shape without a backend migration.

Hub-side typed mirror of the @openalicelabs/presets engagement catalogue (qa-host / battle-chat / cozy-hangout / coding-stream / lecture-moderator / talk-show-panel). Drives the Studio preset picker; the streamer's selected id rides on agent_config.products.live.preset_id and is forwarded to live-control's /live/start request.

Per-broadcast Host Health card on /account/streams. Polls /api/streamhost/heartbeat every 15s and renders a RSS / disk / ffmpeg / RTMP / interruptions / last-frame summary plus a Reset host button.

Hub poll management surface — Create modal, active poll panel with countdown + Close-early, history list. Mounts under /account/streams when a broadcast is live.

Two buttons in the Hub's stream-destinations page that open the live renderer scene URL (with agents) and a no-agent demo room for previewing without going on-air.

Studio-side picker for the per-stream visual theme. 7-preset gallery + custom-override editor (colors / fonts / texture / corners / shadow / motion) + live iframe preview. Persists to agent_config.products.live.branding.theme — the same JSONB the live page reads.

Hub-side mirror of openalice-live's StreamTheme contract — types + presets duplicated so the Studio theme picker can render the catalogue and persist `branding.theme` without pulling in the entire live-renderer package.

Hub-side picker section for the per-stream sound-effect engine. Master toggle + volume + 5-preset gallery (silent / subtle-warm / arcade / sci-fi / nature) + per-event URL & volume overrides. Persists into branding.theme.sfx — the same JSONB the live page's SfxPlayer reads.

Mid-stream theme flip UI — compact preset chips that fire a transient `branding.theme` payload onto the live-control bus so the streamer can change the look mid-broadcast without editing the persistent agent_config. Shows a banner when the live theme differs from the saved one.

Persist the per-stream theme into agent_config.products.live.branding.theme via the SDK's putAgentConfig — preserves every other live-product field on the same object.

Hub page for connecting a YouTube channel (OAuth youtube.readonly + youtube.force-ssl), inspecting granted scopes, and toggling per-tenant mod policies. Companion of /account/streams/[id]/chat-mod. Drives the YT Tier 1 wave Hub UI surface.

Hub card surfacing the persona oauth_audit_log feed for the calling tenant on /account/youtube. Renders op + status + ts + truncated IP. Powered by GET /v1/me/youtube/audit.

Hub page for the static auto-moderation rule set + shared mod-action audit log. Companion of /account/youtube + /account/ai-moderation.

Time / IP formatters used by the YouTube settings page (expires-in countdown, "last refreshed" indicator, audit-feed IP truncator).

Studio Hub chat tab — subscribes to /auth/ws for cross-platform chat (Twitch/YouTube/Kick/TikTok) and writes back via live-control /live/chat-out so streamers monitor + reply without leaving the Hub.

Hub-side wrapper around live-control `/live/chat-out`. POSTs a JWT-authed chat reply to the per-broadcast chat-bridge fan-out so the streamer can reply to Twitch/YouTube/Kick chat from inside the Studio Chat tab.

Internal-secret-gated POST receiver for the openalice-stream-host daemon's 30s heartbeat. Stashes the latest payload per (user_id, host_id) so /account/streams can render a Host Health card.

Catch-all reverse proxy from openalice-app to internal persona-server. Forwards Authorization + streams multipart bodies; passthrough for status + headers. Same-origin to the Hub so CORS is moot.

Catch-all reverse proxy from openalice-app to internal openalice-radio. Forwards Authorization + passes JSON bodies through. Same-origin to the Hub so CORS is moot.

Browser-facing JWT-gated read for the stream-host heartbeat snapshot. Returns hosts for the calling user (sub claim) by reading the same in-memory store the internal POST receiver writes to.

Completes the YouTube OAuth round-trip server-side — state check, code exchange, channel snapshot, signed handoff cookie, redirect to /account/youtube?just_connected=1. Client-side /complete finishes the persona POST.

Client-side completion of the YT OAuth round-trip — reads the handoff cookie set by /callback, verifies its signature, forwards to persona /v1/me/youtube/oauth-tokens with the user's Bearer JWT.

Builds Google OAuth URL with youtube.readonly + youtube.force-ssl + youtube scopes, stashes CSRF state cookie, redirects to Google. Companion of /api/youtube/oauth/callback. Drives /account/youtube Connect button + the stream-key auto-fetch flow.

Public form that requests a password-reset link by email.

Public login + signup form with two-leg MFA prompt. Honors

Set a new password using a single-use reset token.

Validate `?return=<url>` query params for post-login redirects.

Verify the email-verification token and bounce to /account.

Custom-font gallery — list, upload (drag-drop + file picker), rename, delete with confirm, "Use as display/body/mono" hooks for the Theme picker.

Shared async confirm() dialog + useConfirm() hook. Replaces native window.confirm() across the Hub.

Top-level OpenAlice ecosystem launcher tiling Alice, Social, World, Persona, Live, wrapped in the shared EcosystemShell.

Hub home widget listing users currently online across the ecosystem (last_seen ≤ 2 min, status ≠ invisible). Polls every 30s.

Verify openalice-auth-issued access JWTs on the Hub. Used by routes that need a local user_id from the bearer without forwarding to persona.

Typed client for /v1/me/agents on persona-server. Powers the AgentPicker dropdown and the per-agent settings page.

Typed client for the AI moderation REST surfaces on persona-server. Powers `/account/ai-moderation` settings + pending-review + training-feedback panels.

Shared apiFetch() helper — Bearer header + JSON parse + error normalization. Backs every src/lib/*Api.ts client.

Typed client for /v1/me/audio CRUD on persona-server — Bearer JWT, multipart upload, JSON rename, public URL decoration. Powers the Hub Music & Audio picker.

Typed client for /v1/me/fonts CRUD on persona-server — Bearer JWT, multipart upload, JSON rename, public URL decoration.

Reconstructs the public origin (proto://host) from a NextRequest by honouring NEXT_PUBLIC_HUB_BASE_URL + X-Forwarded-Host/Proto, falling back to nextUrl.origin. Fixes 0.0.0.0:3203 leaking into OAuth redirects.

Typed client for /v1/me/agents/:id/idle-config — backs the Hub's Idle behaviour section.

Canonical scene-mode catalog for the Hub. Mirrors openalice-live/SCENE_REGISTRY. Drives "Allowed scenes" config + channel-point trigger validation.

Hub-side typed client for Discord-Style Lounge — listing rooms + Phase-4 moderation primitives (bans, mutes, mods, settings).

Live WS subscription client for the Hub Reports tab — opens the chat WS, sends subscribe_mods after joined, surfaces report_received/report_resolved, reconnects with exponential backoff, signals fallback after 3 failures/60s, 30s heartbeat ping.

Typed client for /v1/me/audio/generate (AI music generation via Lyria 3). Same Bearer JWT + same-origin BFF transport as audioApi. Powers the Hub generate page.

Typed client for /v1/me/polls (engagement polls). Powers the Hub Create-poll modal + active poll panel + history list.

Typed client for /v1/me/redemption-triggers CRUD on persona-server. Powers the Hub Channel-Point Triggers page where streamers bind viewer redemptions to live actions.

Typed client for the per-agent soundboard kill switch on persona-server. Powers the Hub agent-settings toggle.

Typed client for /v1/me/sounds CRUD + play on persona-server. Powers the Hub Soundboard page where streamers upload + tag SFX for the agent's `play_sound` tool.

Typed client for the static-mod REST surface on persona-server. Powers `/account/youtube/auto-mod` Static rules tab + Action log tab.

React hook that auto-dismisses an error string after a configurable timeout. Single source of truth for the Hub's auto-fading error banners.

React hook that redirects to /login?return=<path> when a page's error state indicates an expired session.

Curated voice catalogue + browser-native TTS preview for the per-agent Voice editor. Lists ElevenLabs handles + the Default sentinel; preview uses SpeechSynthesisUtterance locally so sliders demo without burning ElevenLabs quota.

Typed client for the per-tenant VRM library on persona-server. Powers the Hub's per-agent Avatar picker.

Typed client for YT OAuth + mod-page surfaces on persona-server. Powers `/account/youtube` settings page + `/account/streams/[id]/chat-mod` mod view.

HS256 JWT helpers (sign + verify) for the YouTube OAuth callback handoff cookie. Uses SHARED_JWT_SECRET + aud="oa-yt-handoff".

AI music generation page. Lyria 3 via OpenRouter, $0.08/song, $10/month default cap. Async job lifecycle with 5s polling, inline player + add-to-BGM hand-off, recent generations history.

Edit display_name, bio, avatar_url, banner_url, pronouns. One profile across all 6 OpenAlice products.

HTTP server for openalice-atlas — REST endpoints, /mcp JSON-RPC for agents, /health, /metrics, internal rescan hook. Auth via openalice-axum-common + ATLAS_INTERNAL_SECRET.

Org-wide indexer — walks every git repo under ATLAS_ORG_ROOT, parses @feature blocks, reads manifests, writes to Postgres. Delta-driven via content-hash cache.

Atlas dashboard — hero constellation, stats readout, full repo grid sorted by last activity. Server-rendered against atlas-api with 60s revalidate.

Atlas feature ledger — searchable / filterable index of every @feature in the org. Filters serialize to query params; server-rendered.

Atlas 3D module-graph viewer — force-directed React Three Fiber rendering of repos as nodes, deps as edges. Hover surfaces detail card; click navigates to /repos/[name].

Atlas root layout — loads Fraunces + IBM Plex Mono, mounts the persistent observatory frame (starfield, grain, top eyebrow, compass nav), applies security headers via next.config.

Atlas repo-detail page — magnification of a single repo with magnitude, status, README excerpt, full feature ledger grouped by category, source-file pointers.

Atlas repos-index — alphabetical chart-style table of every observed repo. Counterpart to the dashboard's by-activity grid.

Read the user's unified agent config — shared identity (avatar + VRM), voice settings (TTS+STT provider/voice/language/emotion/pace), and per-product enable+system-prompt for live/social/persona/world. Returns a built-in default when no row exists yet.

Upsert the user's agent config. Validates tts/stt providers against the known-good allowlist and per-product JSON shape. Partial updates supported — fields the request omits keep their current values.

Read the user's current studio broadcast config (preset_id + per-stream overrides). Defaults to {preset_id="qa-host", overrides={}} when no row has been saved yet — first-time streamers don't have to click anything before going live.

Upsert the user's studio broadcast config. Validates preset_id against the @openalicelabs/presets allowlist; rejects unknown ids with 400. Returns the persisted row so the client can mirror updated_at.

Persist a chat-read source (YouTube / Twitch / Kick) — the config blob is encrypted at rest by the same crypto pipeline as stream_destinations. Returns the masked public shape.

Hash a password with Argon2id using a per-call random salt.

List the user's paired devices — Hub /account/devices renders this.

Exchange a pairing code for a 90-day device-scoped JWT (audience = live + persona). Unauthenticated by design — the code itself is the credential.

Generate a short-lived pairing code (8 chars, 10 min TTL) the user types into openalice-stream-host. Code is single-use; claiming it issues a 90-day device-scoped JWT.

Revoke a paired device — sets revoked_at, the issued JWT's jti goes into the revocation set so subsequent calls from that token are rejected.

Consume an email-verification token (looked up by SHA-256 hash). Marks the user verified and the token used. Idempotent — already-verified users get 200 with the same payload.

Issue a new email-verification token for the authenticated user, hash it, persist with 24h expiry, and "send" the verification link via the email stub.

Disable MFA after re-confirming the user's password (defense against a session-stealing attacker silently turning MFA off). Clears mfa_secret + mfa_enabled.

Begin MFA enrollment — generates a fresh TOTP secret, stores it on the user (NOT yet enabled), and returns the secret + otpauth URL so the client can render a QR. Re-running before /auth/mfa/verify rotates the secret. Idempotent against an already-enabled user — returns 409 so the client tells the user to disable first.

Confirm enrollment by submitting a code derived from the secret stored at /auth/mfa/setup. On success, mfa_enabled flips to true and subsequent /auth/login flows require a second factor.

Begin a YouTube (Google) OAuth flow — generates a state nonce, persists it server-side, returns the Google authorize URL the client should redirect to. The callback will create a `chat_sources` row with the user's refresh + access tokens.

Issue a password-reset token for the given email and send the reset link via the email stub. Always returns 204 — never reveals whether the email is registered (timing attacks aside, this stops trivial account-enumeration).

Consume a password-reset token (looked up by SHA-256 hash) and rewrite the user's password. Marks the token used and revokes ALL outstanding refresh tokens for the user (forces re-login on every device).

List users with last_seen ≤ 2 minutes ago who haven't set their status to invisible. Powers the Hub "who's online" widget and any cross-product presence indicator.

Service-to-service entry point — POST a notification (optionally targeted at a specific user) and the auth WS hub fans it out to every connected client. Authenticated by a shared secret in the `X-Internal-Secret` header (env `INTERNAL_BROADCAST_SECRET`). Producers: social-api on DM, persona on session events, billing on plan changes.

Service-to-service entry — POST a normalized chat message from any platform connector (openalice-chat-bridge for YouTube/Twitch/Kick/TikTok) and the broadcast owner's connected agent receives it as a `chat_message` event over /auth/ws. Bypasses the notification cooldown (chat is a stream). Authenticated by X-Internal-Secret.

Service-to-service entry — POST a mechanical chat aggregation tick (n-gram topics + mood + highlight quotes over a fixed window) from the chat-bridge feed-aggregator. The broadcast owner's connected agent receives it as a `chat_feed` event over /auth/ws — a cheap "what is the room doing?" heartbeat that costs zero LLM tokens to produce. Authenticated by X-Internal-Secret.

WebSocket fan-out — clients open with ?token=ACCESS_JWT and receive cross-product real-time events (presence_changed today, notifications + DM events later). Server-push only; messages from the client are currently ignored.

List the authenticated user's active refresh-token sessions (one per browser/device login). Each row carries user_agent, created_at, last_used_at, and a `current` flag marking the device this request came from.

Revoke a specific refresh-token session by id. Marks the row revoked and blacklists its current jti so the next /auth/refresh from that device fails. Existing access tokens on that device survive until natural expiry (≤1h).

Persist a per-platform stream destination — label, platform, optional RTMP URL override, encrypted stream key. Returns the masked public shape.

Permanently delete a stream destination.

Service-to-service endpoint for the broadcaster — given a user_id (path) and optional destination ids (query), returns enabled destinations with PLAINTEXT stream keys. Authenticated via X-Internal-Secret. The broadcaster is the only caller.

List the user's stream destinations with masked stream keys ("live_••••wxyz" preview).

Reveal the plaintext stream key after re-confirming the user's password. Stream keys aren't returned by the list endpoint by design — this is the dedicated unmask path.

Update a destination's label or enabled flag. Stream-key rotation is a delete + create operation by design.

Exchange a refresh token for a fresh access+refresh JWT pair (rotation).

Permanently delete the authenticated user's account and revoke all tokens.

Update authenticated user's profile fields (display name, avatar, bio).

Verify email+password and issue access+refresh JWT pair.

Exchange a pre-MFA token + TOTP code for a full session. Issued only when /auth/login responds with mfa_required=true. Pre-MFA token is audience-restricted so it can't be used against any downstream service if leaked.

Return current authenticated user's profile (id, email, username, status). Side effect — bumps users.last_seen so the user surfaces in the online-users feed.

Register a new user with email + username + password (Argon2id), returns access+refresh JWT pair.

Run every registered asset through the mock generator pipeline (planning + dry-run).

Procedurally generate all VRM character texture sets (free, no external APIs).

Standalone Three.js GLB viewer for inspecting a single forge mesh in the dashboard.

Three.js viewer that instances meshes per InstanceGroup transforms to render a forge scene.

Procedurally generate all GLB meshes (trees, props, terrain) free of external API cost.

List asset definitions for a registry category (terrain, character, prop, scene...).

Free-text search across registered asset definitions.

Build six demo scenes — JSON specs composing mesh GLBs into playable showcase environments.

Dry-run a texture generation — return prompt, settings, and cost estimate (no API call).

Authenticate via JWT > session > API key, fall through to anonymous; exempt paths bypass.

HTTP reverse proxy with auth, rate-limit, circuit breaker, and prefix-stripped backend forward.

Bidirectional WebSocket proxies for /ws/rt, /ws/voice, /ws/persona — bridge browser to internal services.

Per-user token-bucket rate limiter (separate user/anon caps) using DashMap.

Per-backend circuit breaker (Closed/Open/HalfOpen) — short-circuit failing services with 503.

OpenAlice Labs research site home — mission, project highlights, hero.

List of OpenAlice Labs projects with descriptions, tech stacks, and links.

Research-area landing page listing topics under active investigation.

Team page showing OpenAlice Labs members and roles.

Marketing page for the Alice agent — capabilities, memory, tools, integrations.

OpenAlice marketing home page — product overview, key features grid, hero, CTA.

Marketing page for Persona — VRM avatars, voice, AI character creation.

Public pricing page — tiers, plans, FAQ for OpenAlice products.

Marketing page for Social — Discord-like rooms with humans + agents, voice, video.

Standalone Agent Desktop OS — fullscreen virtual desktop the agent drives via the same scene-control WS as the OBS scene mode. Persists window layout in localStorage so the surface survives reloads. Foundational v0 of the "fake OS in the browser" track.

Server-side proxy that mints openalice-browse sessions for the OS BrowserApp. Keeps the internal secret on the server.

Liveness probe — returns 200 with timestamp for monitoring + Traefik healthchecks.

Server-side proxy that mints openalice-pty sessions for the OS TerminalApp. Keeps the internal secret on the server and hands the browser a fully-formed ws_url with a one-shot token query param.

Per-stream background-music engine. Hidden <audio> element loops the streamer's chosen BGM track (preset OR custom upload). Drives volume / loop / fade-in / fade-out / cross-fade-on-track-change / auto-ducking-when-TTS-speaks. Decoupled from voice + SFX surfaces; ducking listens to oa-voice-chunk + oa-voice-finished postMessages.

Wires the bgmRotation policy + persona-server SSE rotation events into the live scene BGM pipeline. Subscribes to idle.bgm_change, falls back to a client-side max-loops trigger, and applies a 2s crossfade via the underlying BgmPlayer.

Bundled background-music preset library — five royalty-free vibes (lofi-amber, synthwave-cyan, jazz-cafe, ambient-spacy, silence). Hub picker uses these as starting points; tenant-uploaded tracks plug into the same dropdown via the persona /v1/me/audio CRUD.

Live-page radio channel subscriber. Resolves a radio:<slug> bgm_source into a WebSocket subscription against openalice-radio; each now_playing frame updates the underlying BgmPlayer config so the live page picks up new tracks with the same cross-fade / duck-during-tts plumbing as static BGM.

Sound-effects audio engine for the live stream player. Listens to chat append / mood transition / gesture / subscribe / caption events and plays a short clip per channel, debounced per event type. Master / per-event volume + per-event URL overrides via `branding.theme.sfx`. Mounts only when `theme.sfx.enabled === true` so SFX-disabled streams pay zero cost.

Five bundled sound-effect preset vibes (silent / subtle-warm / arcade / sci-fi / nature) — each a coordinated set of audio clips for the stream player's chat, mood, gesture, subscribe, and caption events. Hub picker uses these as starting points; per-event URL overrides land on top via `branding.theme.sfx.sfx_<event>_url`.

Public form that asks tenants to email a password-reset link. Always returns generic copy to avoid account-enumeration leaks.

Public login form — email + password, two-leg MFA prompt for accounts with TOTP/email-MFA.

Heuristic password-strength meter (close-enough to zxcvbn) plus visual bars. Stays local until v0.7 promotes a shared meter.

Lands here from the password-reset email link. Form: new password + confirm. POSTs to /tenants/reset-password.

Stash tenants-issued JWT into the shared SSO localStorage slot.

Public signup form — email, username, display name, password (with strength meter), ToS opt-in.

Confirms the verification token from the welcome email. Auto-POSTs on mount; surfaces a re-send button on failure when the user is logged in.

Game-style up-front asset preloader — fetches every URL the active theme references (VRM via persona, HDR env, BGM, scene background video/image, parallax layers, custom fonts, SFX bundle) before the scene fades in. Branded progress UI with X/Y count and percentage. 30 s safety timeout, soft per-asset failures don't block the scene. Eliminates the late-load "model loads on first scene with avatar" hiccup.

Marketing landing for OpenAlice Live — stream with Alice as AI co-host.

Real xterm.js terminal in the Agent Desktop OS — connects to openalice-pty over WebSocket and renders any TUI (claude, vim, btop, htop, neovim, tmux) pixel-perfect with full ANSI escape support.

AFK placard with a tasteful sleeping-moon SVG animation, breathing BRB title, and desaturated gradient mesh that signals "paused". Atelier-only, prefers-reduced-motion respected.

Subscribe / follow / donation celebration-overlay layer for the live broadcast page. Listens for `oa-event-celebrate` window events and slides a branded animated card into the scene with platform-coloured chrome, a confetti burst, optional TTS read-out, and per-platform SFX. Queues up to 16 events; honours reduced-motion. Mount-time gated by `theme.event_celebration.enabled`. Closes the polish gap to Streamlabs / StreamElements / Neuro-sama-grade event handling.

Editorial chapter card for between-segments transitions ("1 / 3 — Coding session"). Twin-band gradient mesh, oversized chapter index, slow horizontal wipe transition. Calm, intentional, premium.

Catalog of Live broadcast scene modes — VRM fullscreen + static placards (starting-soon / be-right-back / outro). Each scene declares its voice + render cost so the page knows whether to attach the SFU and the admin can warn on GPU-less hosts.

Administrative toast for AI-driven mod actions on the live scene. Listens for `oa-mod-action` window events and paints a muted lower-left card with an inline Undo button. Separate from the celebratory overlays — visually neutral on purpose.

Polished farewell placard with social-handle pills, optional next-stream timestamp, Solar Amber Subscribe CTA, and Plasma Cyan gradient mesh distinct from the warm starting-soon family.

Shared placard primitives — Atelier-themed gradient mesh, brand watermark, social pills, BGM "now playing" pill, countdown clock. Used by starting-soon / be-right-back / outro / intermission.

Engagement poll overlay for the live scene page. Listens for oa-poll-opened / oa-poll-vote / oa-poll-closed window events and paints a Q+A card with growing option bars + linear countdown + winning-option highlight on close. Optional per-platform colour theme.

Channel-point / SuperChat redemption toast for the live scene page. Listens for `oa-redemption-triggered` window events and paints a per-platform branded card ("🎁 ViewerName redeemed «Evil Laugh»"). Separate from the EventCelebrationOverlay (which handles sub/follow/cheer); this one is the dedicated viewer-trigger surface.

Animated 2D backdrop renderer for vtuber scenes — color / image / video / preset modes plus parallax layers, atmospheric particles (snow / cherry-blossoms / embers / dust / rain / stars), and drift (slow-pan / Ken-Burns). Pure CSS keyframes, no canvas, no WebGL — runs at ~0% GPU on the no-GPU broadcaster host. Reduced-motion strips every animation.

Polished pre-roll placard with Atelier gradient mesh, animated countdown to start_at_ms, brand block, and "now playing" pill. Atelier-only colours, calm motion, prefers-reduced-motion respected.

Floating reviewer-navigation overlay on the live demo page (?demo=1&picker=1) — six tabs (Scene / Render / Avatar / Theme / Background / Audio) let a reviewer hop between any combination of scene modes, avatar render modes/presets, theme presets, background presets, BGM and SFX presets in two clicks each. Pauses the auto-cycling demo timeline so selections stick. URL state syncs via history.replaceState so refreshes keep the reviewer's working selection.

Canned timeline of scene/mood/chat/gesture/window/splitscreen events the demo room replays on a loop so we exercise every renderer mode without requiring live agents or a WS connection.

Route-segment ErrorBoundary for /scene/[user]. Any unhandled error in the OBS Browser Source page renders a "Reconnecting…" card on a dark background instead of a blank surface, then auto-reloads after 3s so transient failures (WS drop, iframe race, persona crash) recover without operator intervention.

OBS Browser Source endpoint — multi-mode renderer (VRM fullscreen + static placards) driven by ?scene= query param and a live-control WebSocket so the agent's ChangeScene ToolCall flips scenes mid-stream without restarting the broadcaster Chromium.

Agent Marketplace browse + pair UI — capability-scoped grants against openalice-tenants.

Per-channel volume mixer + BGM picker for the active broadcast. Sliders for mic / desktop / TTS / BGM (linear UI, log-mapped on send), default royalty-free BGM presets, custom URL field, play/pause/skip transport, persisted per-broadcast in localStorage, debounced 200 ms before POST to live-control.

Multi-platform live chat reader + reply box for the streamer. Subscribes to the live-control scene WS for inbound, posts to chat-bridge for outbound. Lets the streamer talk to viewers without leaving studio.

Streamer-facing studio — shows the OBS browser-source URL with copy-to-clipboard. Login required.

First-run checklist for Live — avatar, voice, stream destination, desktop pairing, branding. Each step deeplinks to the editor that fixes it.

Per-user TTS / STT / avatar / system-prompt editor for the Live product. Saves to agent_config; takes effect on the next /live/start.

Privacy & Data settings — consent flags, GDPR export, audit log, paired agents, account deletion.

Browser HTTP client for openalice-tenants — consent flags, audit log, GDPR export, account deletion, paired-agent grants.

Per-stream visual theme for the broadcast player. Decouples streamer-facing scene look from the Atelier platform tokens — themes are CSS variables (bg / fg / accent / fonts / texture / motion) scoped to the player's <main> element. Streamers pick from a preset library (vtuber-warm, vtuber-neon-cyan, minimal-mono, glass-dark, vintage-sepia, pastel-bubblegum, editorial-print) or pass a fully-custom override. Atelier values are the fallback so existing broadcasts paint identically.

Admin endpoint — issue an API key with per-day request limit and per-month token cap.

Authenticated, rate-limited proxy to the embedding backend (/v1/embed).

Authenticated, rate-limited proxy to the NER backend (/v1/ner).

Authenticated, rate-limited proxy to the reranker backend (/v1/rerank).

Per-key usage report — requests today + tokens this month vs configured caps.

VRM gallery — list, upload (drag-drop + file picker), select active, delete with confirm. Uses Atelier primitives.

Typed client for Discord-Style Lounge Phase 2 — room CRUD + participant management.

Typed client for /v1/me/vrms GET/POST/DELETE — bearer JWT, multipart upload, public URL decoration.

Pluggable agent transport (REST, WebSocket, MCP) for sending messages and streaming replies to a Persona.

Persona-side adapter that drives the OpenAlice agent contract (ConnectorEvent in / ToolCall out) so any AgentRuntime — Alice, Hermes, custom — can power a Persona without code changes in the embed.

REST-backed AgentRuntime adapter for Persona — wraps a "POST text → get text" backend so the AgentRuntime contract works today without server-side contract changes. Re-export of the protocol package's canonical impl.

React hook wiring ProtocolAgentConnector + RestAgentRuntime + agent_config fetching for the Persona embed. Drop-in replacement for raw /api/chat fetch — once Alice ships a contract endpoint, only this hook's runtime changes.

PATCH /v1/me/agents/:agent_id/idle-config — per-agent idle behaviour thresholds + kind toggles. Backs the Hub's Idle behaviour section on /account/agents/[id]/settings.

Per-agent voice + avatar override PATCH endpoint. Lets the Hub edit voice_id / stability / similarity_boost / speed / vrm_id / display_name without rolling an openalice-auth migration. Tenant-scoped via the bearer JWT.

Return the full per-agent settings (soundboard, voice stub, persona stub) for one agent_id. 404 when the id doesn't belong to the caller's tenant.

Load and drive VRM avatars — expressions, mouth lipsync, tick updates via three-vrm + GLTFLoader.

Screen-space post-processing render modes for the VRM avatar (3d / 2d-toon / 2d-flat). Applies a custom EffectComposer chain — toon posterize, sobel outline, chromatic aberration, scan lines, bloom-tinted hologram, CRT flicker — over the rendered scene WITHOUT touching the VRM's materials. The 3D path collapses to a null composer (zero cost).

Multiplayer presence — direct WebSocket to RT service, broadcasts position at 10fps, returns remote players.

WebRTC voice chat for Persona rooms — push-to-talk, mute/deafen, screen share, webcam, VAD.

Distance-based 3D audio for remote users — Web Audio PannerNodes follow player positions in scene. Singleton AudioContext shared across hook callers.

WebSocket client for openalice-anim — receives synthesized pose + blendshape frames at 60 Hz and applies them to the AvatarAnimator. When connected, suppresses the procedural idle path so the two don't fight for bones.

React hook that wraps RealtimeManager — manages mount/unmount lifecycle, exposes status for UI badges, returns the manager for subscribe/send/etc.

Poll A2A messages and forward each new one as an HTML-formatted Telegram message.

Hybrid Logical Clock (48-bit ms + 16-bit counter), lock-free via AtomicU64.

Compiled subscription plan for incremental view maintenance, evaluates deltas without full re-scan.

Periodic snapshots with Blake3 content hashing for fast WAL-replay recovery.

Case-insensitive substring search over message text fields, room-scoped, capped limit.

WebSocket gateway with subscribe/unsubscribe/mutate, JSON or MessagePack frames, JWT auth.

Upsert or delete an entity (Room/Persona/Message/Presence) with WAL persistence.

Return the current state snapshot with the highest committed sequence number.

In-memory MVCC store with atomic batch commits and bounded delta-log broadcast.

Realtime WebSocket bridging messages, typing, presence, pins, reactions, calls into the social store.

P2P-mesh WebRTC voice channel with mute/deafen, screen share, webcam, noise suppression.

Send a friend request to another user — they accept or decline.

Create a 1:1 or group DM channel between two or more users.

Case-insensitive content search within a channel, paged by limit.

Send a message into a server channel — broadcast over WebSocket to channel subscribers.

WebSocket gateway pushing channel events (message, edit, delete, presence) with JWT auth.

Create a text/voice/announcement channel inside a server.

Create a new server (Discord-like) — owner becomes first member with admin role.

Upload an attachment with MIME validation via magic bytes; S3 (MinIO) primary, local-disk fallback.

Shortcut endpoint to generate a single 3D object (mode=object) with prompt or image.

Submit text or image prompt to generate a 3D world via NANO-PATH (multi-view → Gaussian Splat).

Poll a generation job's status (Queued/Generating/Fitting/Completed/Failed) with progress.

GPU worker long-polls the queue (≤30s) for a pending DiffSplat/MV3D task.

Download a generated 3D world (PLY/GLTF) for client-side WebGPU rendering.

Persist a composed world state (objects, camera presets, lighting) to disk by world_id.

Shared error message helpers for API hooks — extracts user-facing message from ApiRequestError, generic Error, or unknown, and strips bearer tokens / auth credentials before display.

Tiny generic helper that owns {data, loading, error} for an async fetch — collapses three useStates into one.

Verify the current session against /auth/me on mount. On 401 or missing token, clear auth + redirect to /login. Returns the authenticated user once verified.

Fetch billing status + plans, expose changePlan against the active OpenAliceClient.

List/create/delete API keys against the active OpenAliceClient. Exposes newKey + clearNewKey for one-shot reveal.

Returns an async (email, password) → AuthActionResult that drives AuthProvider.login + sets the SSO sessionStorage flag. Translates RateLimitError into a UI-friendly message with retryAfter seconds.

Returns an async () → void that drives AuthProvider.logout, then clears the SSO sessionStorage flag. Errors during logout are swallowed — local state is cleared regardless.

Fetch the currently authenticated PublicUser from the active OpenAliceClient and expose loading/error/refetch.

Returns an async (name, email, password, _confirm?) → AuthActionResult that drives AuthProvider.register + sets the SSO sessionStorage flag. Translates RateLimitError into a UI-friendly message.

Fetch usage rollup for the last N days from the active OpenAliceClient.

Legacy adapter — fetch the current User (legacy shape) from the active OpenAliceClient. Prefer useMe() for new code.

Client-side route guard — renders skeleton until auth resolves, redirects to /login if unauthenticated.

Shared React context for cross-domain SSO — JWT in localStorage, HttpOnly cookie probe, cross-tab sync.

Hook that opens a WebSocket to /auth/ws while the user is signed in, dispatches each incoming event envelope to a handler, and reconnects with exponential backoff on disconnect.

Centered auth-page layout — atmospheric grain + halo, brand mark, card, footer.

OpenAlice wordmark / monogram — SVG, crisp at any size.

Responsive auto-fit grid for stat / card lists.

Pulsing chip for live/recording state. Plasma cyan or warm red tone.

Standard page title + description + actions row.

Sub-section title row (h2-weight) inside a page.

Left-nav + main-content layout for settings/account pages.

Sets data-theme on document root, persists to localStorage, optional system mode.

Circular avatar with image fallback to initials and optional ring.

Chip / tag — 2px radius, hairline ring, semantic + brand variants.

Full-width persistent message with left-edge accent and optional dismiss.

Chevron-separated path navigation. Last item is current page.

Tactile button primitive — five variants, three sizes, loading state, spring press.

Surface card with hairline border. Optional hover-lift via `interactive`.

Square checkbox with smooth check animation, native semantics, validators.

Searchable typeahead select. Custom filter, keyboard nav, validators.

Clipboard copy with success-state animation.

Compositional dialog API on top of Modal — header, title, description, footer slots.

Compound dropdown menu — trigger / content / item / separator / label, click-outside + ESC close.

Centered empty-state panel — icon/illustration slot, title, body, optional CTA.

Composes Label + control + helper/error + optional validators. Universal form row.

Hairline text input — supports validators, helper text, icon slots, monospace mode.

Keyboard-shortcut chip. Multi-key combos via `combo` (string) or `keys` (array).

Semantic form label with required-star slot.

Centered dialog primitive — focus trap, ESC, scroll-lock, glass backdrop with grain.

Page-number navigator with prev/next + ellipsis.

Bar progress — determinate (0-100) or indeterminate sliding bar.

Radio button group with native semantics + Atelier styling + validators.

Scrollable container with Atelier scrollbar styling.

Headless select with keyboard nav, click-outside close, and validators.

Hairline horizontal/vertical divider with optional decorative gradient variant.

Loading placeholder with warm shimmer.

Range slider — native input semantics, brand-500 fill, focus ring.

Indeterminate circular loader. Matches button sizes for inline use.

Pill toggle. Solar amber active state, hairline ring, native checkbox semantics.

Hairline-underline tabs with keyboard arrow nav.

Multi-line text input with auto-resize, char count, and validators.

Hover hint with 4-position support, configurable delay, hairline border.

Cmd+K / Ctrl+K command palette — modal overlay with fuzzy filter over a flat list of commands. Mounted by EcosystemShell so every product gets the same shortcut surface.

Persistent cross-product chrome — left sidebar with product switcher, top bar with account chip. Wraps each product's layout so the 5 products feel like one app.

Voice tool schemas (voice_join, voice_leave, voice_speak, voice_status) for AI agents to participate in rooms.

Active speaker detection using LiveKit 2-gate + EMA over RFC 6464 audio levels.

Issue a signed JWT (HS256) for joining a room with publish/subscribe scopes.

Pick the best node for a new room using strategy (Any, LowestSysload, TwoChoice, RegionAware).

Per-participant connection quality MOS score using LiveKit E-model with asymmetric smoothing.

Create a new voice room with a name and participant cap.

List active voice rooms with participant counts.

WebSocket signalling channel for join/leave/mute/offer/answer/ICE.

Single-port UDP mux with RFC 5764 packet classification (STUN/DTLS/RTP/RTCP).

Shared protocol-level WebRTC client for the openalice-voice SFU. Powers Live (recvonly), World (full duplex), and future Social/Persona consumers.

Shared WebRTC voice client package — kills duplication between Live's listener and World's full-duplex voice chat. Future home of Social DM calls and Persona voice embed.

useVoiceClient — React hook wrapping VoiceClient with audio elements, VAD, deafen, PTT.

World-side adapter that wires room presence + spatial chat + voice utterances into the OpenAlice agent contract. Same AgentRuntime works in Live, Social, Persona, World — World just adds proximity filtering and exposes change_scene tool calls back to the host renderer.

React hook wiring WorldAgent + RestAgentRuntime + agent_config fetching for 3D rooms. Drop-in for legacy chat — once a contract-native runtime ships, only this hook's runtime ctor changes.

Biome-aware Forge flora — Poisson-spaced canopy/detail/ground meshes per biome with wind-reactive shader.

Full island scene — terrain, ocean, sky, weather, flora, portals, multiplayer avatars, post-processing.

Procedural island terrain via FBM simplex noise — heightmap, biome map, vertex colours, normals, indices.

Poisson-disc vegetation placement on a terrain biome — deterministic, min-spaced, optional underwater.

WebRTC voice chat in 3D world rooms via openalice-voice SFU. Now powered by @openalicelabs/voice-client.

24h day/night cycle with 8 phases, 6 weather types, lightning, rainbow, wind, server-authoritative sync.