feat(aesthetic): distinct grand-hotel music + better cyber-fixer voice

- grand-hotel no longer reuses noir's jazz loop: music.src now points at a new
  lazy-generated /api/music/grand-hotel/atmosphere route that renders the
  world's musicStylePrompt (1920s lobby band) via ElevenLabs Music on first
  request, caches to disk, and falls back to the noir loop without a key —
  mirroring the existing lazy SFX pipeline.
- cyber-fixer voice: replace the stock 'Adam' (generic-AI sounding) with Matt
  (natural, hyper-conversational) and retune voiceDirection for a natural voice
  (was tuned for the robotic one).

Author: komod0

src/app/api/music/[world]/atmosphere/route.test.ts

@@ -0,0 +1,96 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { NextRequest } from "next/server";
+
+// Mock the disk-cache store so tests don't touch the filesystem.
+const mockReadAtmosphereMusic = vi.fn();
+const mockSaveAtmosphereMusic = vi.fn();
+const mockDeleteAtmosphereMusic = vi.fn();
+vi.mock("@/lib/ai/atmosphereMusicStore", () => ({
+  readAtmosphereMusic: (world: string) => mockReadAtmosphereMusic(world),
+  saveAtmosphereMusic: (world: string, data: Buffer) => mockSaveAtmosphereMusic(world, data),
+  deleteAtmosphereMusic: (world: string) => mockDeleteAtmosphereMusic(world),
+}));
+
+// Mock the ElevenLabs client so no network call is made.
+const mockElevenLabsFetch = vi.fn();
+vi.mock("@/lib/elevenlabs/client", () => ({
+  elevenLabsFetch: (path: string, init?: RequestInit) => mockElevenLabsFetch(path, init),
+}));
+
+function makeRequest(url: string): NextRequest {
+  return new NextRequest(new Request(url));
+}
+
+describe("/api/music/[world]/atmosphere", () => {
+  beforeEach(() => {
+    mockReadAtmosphereMusic.mockReset();
+    mockSaveAtmosphereMusic.mockReset();
+    mockDeleteAtmosphereMusic.mockReset();
+    mockElevenLabsFetch.mockReset();
+    delete process.env.ELEVENLABS_API_KEY;
+  });
+
+  it("returns cached bytes immutable on a cache hit", async () => {
+    mockReadAtmosphereMusic.mockResolvedValueOnce({
+      data: Buffer.from("cached-music"),
+      contentType: "audio/mpeg",
+    });
+    const { GET } = await import("./route");
+
+    const response = await GET(makeRequest("http://localhost/api/music/grand-hotel/atmosphere"), {
+      params: Promise.resolve({ world: "grand-hotel" }),
+    });
+
+    expect(response.status).toBe(200);
+    expect(response.headers.get("Content-Type")).toBe("audio/mpeg");
+    expect(response.headers.get("Cache-Control")).toBe("public, max-age=31536000, immutable");
+    expect(Buffer.from(await response.arrayBuffer()).toString()).toBe("cached-music");
+    expect(mockElevenLabsFetch).not.toHaveBeenCalled();
+  });
+
+  it("redirects to the noir fallback when no key is configured", async () => {
+    mockReadAtmosphereMusic.mockResolvedValueOnce(null);
+    const { GET } = await import("./route");
+
+    const response = await GET(makeRequest("http://localhost/api/music/grand-hotel/atmosphere"), {
+      params: Promise.resolve({ world: "grand-hotel" }),
+    });
+
+    expect(response.status).toBe(307);
+    expect(response.headers.get("Location")).toContain("/assets/noir/noir-jazz-loop.mp3");
+    expect(mockElevenLabsFetch).not.toHaveBeenCalled();
+  });
+
+  it("generates, caches, and serves bytes when a key is configured", async () => {
+    process.env.ELEVENLABS_API_KEY = "test-key";
+    mockReadAtmosphereMusic.mockResolvedValueOnce(null);
+    mockElevenLabsFetch.mockResolvedValueOnce({
+      ok: true,
+      arrayBuffer: async () => Buffer.from("fresh-music"),
+    });
+    const { GET } = await import("./route");
+
+    const response = await GET(makeRequest("http://localhost/api/music/grand-hotel/atmosphere"), {
+      params: Promise.resolve({ world: "grand-hotel" }),
+    });
+
+    expect(response.status).toBe(200);
+    expect(Buffer.from(await response.arrayBuffer()).toString()).toBe("fresh-music");
+    expect(mockElevenLabsFetch).toHaveBeenCalledWith(
+      "/music",
+      expect.objectContaining({ method: "POST" })
+    );
+    expect(mockSaveAtmosphereMusic).toHaveBeenCalledWith("grand-hotel", expect.anything());
+  });
+
+  it("404s for an unknown world", async () => {
+    const { GET } = await import("./route");
+
+    const response = await GET(makeRequest("http://localhost/api/music/not-a-world/atmosphere"), {
+      params: Promise.resolve({ world: "not-a-world" }),
+    });
+
+    expect(response.status).toBe(404);
+    expect(mockReadAtmosphereMusic).not.toHaveBeenCalled();
+  });
+});

src/app/api/music/[world]/atmosphere/route.ts

@@ -0,0 +1,96 @@
+import { NextRequest } from "next/server";
+import { Buffer } from "node:buffer";
+import { isBuiltInAestheticId } from "@/lib/aesthetic/types";
+import { getAestheticDefinition } from "@/lib/aesthetic/definitions";
+import { elevenLabsFetch } from "@/lib/elevenlabs/client";
+import {
+  readAtmosphereMusic,
+  saveAtmosphereMusic,
+  deleteAtmosphereMusic,
+} from "@/lib/ai/atmosphereMusicStore";
+
+export const runtime = "nodejs";
+
+/** Recorded noir score served when generation is unavailable. */
+const FALLBACK_MUSIC = "/assets/noir/noir-jazz-loop.mp3";
+
+/**
+ * Lazy generated per-world atmosphere music — the music twin of the SFX route.
+ *
+ * A world's music src may point at `/api/music/<world>/atmosphere` instead of a
+ * recorded loop (grand-hotel does). On first request the world's
+ * `identity.musicStylePrompt` is rendered through the ElevenLabs Music API,
+ * cached to disk, and served immutable. Without an ELEVENLABS_API_KEY (or on
+ * failure) the request redirects to the noir fallback loop so music never
+ * hard-breaks.
+ *
+ * `?regen=1` busts the cache and re-renders the score.
+ */
+export async function GET(
+  request: NextRequest,
+  { params }: { params: Promise<{ world: string }> }
+): Promise<Response> {
+  const { world } = await params;
+  // The route accepts `<world>` or `<world>.mp3` (audio elements like a real ext).
+  const cleanWorld = (world ?? "").replace(/\.mp3$/, "");
+  if (!isBuiltInAestheticId(cleanWorld)) {
+    return new Response("Not found", { status: 404 });
+  }
+
+  const regen = request.nextUrl.searchParams.get("regen") === "1";
+
+  if (regen) {
+    await deleteAtmosphereMusic(cleanWorld);
+  } else {
+    const cached = await readAtmosphereMusic(cleanWorld);
+    if (cached) {
+      return new Response(new Uint8Array(cached.data), {
+        status: 200,
+        headers: {
+          "Content-Type": cached.contentType,
+          "Cache-Control": "public, max-age=31536000, immutable",
+        },
+      });
+    }
+  }
+
+  const prompt = getAestheticDefinition(cleanWorld).identity.musicStylePrompt;
+  const apiKey = process.env.ELEVENLABS_API_KEY;
+
+  if (apiKey && prompt) {
+    try {
+      const response = await elevenLabsFetch("/music", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          prompt,
+          music_length_ms: 30000,
+          force_instrumental: true,
+        }),
+      });
+      if (response.ok) {
+        const data = Buffer.from(await response.arrayBuffer());
+        await saveAtmosphereMusic(cleanWorld, data);
+        return new Response(new Uint8Array(data), {
+          status: 200,
+          headers: {
+            "Content-Type": "audio/mpeg",
+            "Cache-Control": "public, max-age=31536000, immutable",
+          },
+        });
+      }
+      console.error(
+        `[atmosphere-music] generation failed for ${cleanWorld}:`,
+        response.status,
+        await response.text().catch(() => "")
+      );
+    } catch (error) {
+      console.error(`[atmosphere-music] generation error for ${cleanWorld}:`, error);
+    }
+  }
+
+  // No key / generation failed — fall back to the recorded noir loop so the
+  // world still has a score. Temporary redirect: a later request retries
+  // generation instead of caching the fallback forever.
+  return Response.redirect(new URL(FALLBACK_MUSIC, request.nextUrl.origin), 307);
+}

src/lib/aesthetic/definitions.ts

@@ -422,14 +422,19 @@ const cyberFixer: AestheticDefinition = {
     generate: "inject grid load",
     error: "connection dropped",
   },
-  voiceId: "pNInz6obpgDQGcFmaJgB",
+  // Matt — natural, hyper-conversational American male. Replaces the stock
+  // "Adam" voice, which read as a generic/robotic TTS for the streetwise fixer.
+  voiceId: "pwMBn0SsmN1220Aorv15",
   imageStylePrompt:
     "cyberpunk aesthetic, futuristic cyberpunk command center, neon lights, high-tech overlays, glowing digital HUD, cybernetic implants, wireframe graphics, cyan and magenta accents, rainy futuristic cityscape window, synthwave style, no text or watermark",
   // Dense neon/HUD detail — the higher-fidelity Gemini Pro image model.
   imageModel: "gemini-3-pro-image",
   identity: {
     glowStrength: 1.4,
-    voiceDirection: { stability: 0.2, similarityBoost: 0.6, style: 0.8, speed: 1.1 },
+    // Tuned for Matt (a natural conversational voice): moderate stability so he
+    // stays steady, modest style so the delivery reads as a real person with
+    // edge rather than an exaggerated AI, and a slight speed lift for fixer energy.
+    voiceDirection: { stability: 0.45, similarityBoost: 0.75, style: 0.35, speed: 1.08 },
     musicStylePrompt:
       "dark synthwave — driving arpeggiated bass, neon pads, gated reverb drums, 110bpm, retro-futuristic and propulsive, Blade Runner street energy",
     musicPresets: [
@@ -962,15 +967,17 @@ const grandHotel: AestheticDefinition = {
   // The hotel's foley is GENERATED: each src hits /api/sfx/grand-hotel/<kind>,
   // which renders the identity.sfxPrompts recipe through ElevenLabs text-to-SFX
   // on first request, caches it to disk, and falls back to the noir assets when
-  // no ELEVENLABS_API_KEY is configured. Music still reuses the jazz loop (the
-  // Composer Lab generates real scores on demand).
+  // no ELEVENLABS_API_KEY is configured. Music is likewise GENERATED: its src
+  // hits /api/music/grand-hotel/atmosphere, which renders the
+  // identity.musicStylePrompt through the ElevenLabs Music API on first request
+  // and falls back to the noir jazz loop when no key is configured.
   audio: {
     sfx: {
       typewriter: { src: "/api/sfx/grand-hotel/typewriter.mp3", volume: 0.55 },
       thunder: { src: "/api/sfx/grand-hotel/thunder.mp3", volume: 0.6 },
       phone: { src: "/api/sfx/grand-hotel/phone.mp3", volume: 0.65 },
     },
-    music: { src: "/assets/noir/noir-jazz-loop.mp3", volume: 0.2 },
+    music: { src: "/api/music/grand-hotel/atmosphere", volume: 0.2 },
     ambient: {
       rain: {
         src: "/api/sfx/grand-hotel/ambient.mp3",

src/lib/ai/atmosphereMusicStore.test.ts

@@ -0,0 +1,50 @@
+// @vitest-environment node
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import {
+  saveAtmosphereMusic,
+  readAtmosphereMusic,
+  deleteAtmosphereMusic,
+} from "./atmosphereMusicStore";
+
+describe("atmosphereMusicStore", () => {
+  const originalDir = process.env.A2UI_ATMOSPHERE_MUSIC_DIR;
+  let tempDir = "";
+
+  beforeEach(async () => {
+    tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "a2ui-atmosphere-music-"));
+    process.env.A2UI_ATMOSPHERE_MUSIC_DIR = tempDir;
+  });
+
+  afterEach(async () => {
+    process.env.A2UI_ATMOSPHERE_MUSIC_DIR = originalDir;
+    if (tempDir) {
+      await fs.rm(tempDir, { recursive: true, force: true });
+    }
+  });
+
+  it("saves, reads, and deletes a world's music (round-trip)", async () => {
+    const dummyBuffer = Buffer.from("dummy-music-content");
+    const saved = await saveAtmosphereMusic("grand-hotel", dummyBuffer);
+    expect(saved).toBe(true);
+
+    const read = await readAtmosphereMusic("grand-hotel");
+    expect(read?.contentType).toBe("audio/mpeg");
+    expect(read?.data.toString()).toBe("dummy-music-content");
+
+    await deleteAtmosphereMusic("grand-hotel");
+    expect(await readAtmosphereMusic("grand-hotel")).toBeNull();
+  });
+
+  it("returns null if a world has no cached music", async () => {
+    expect(await readAtmosphereMusic("noir")).toBeNull();
+  });
+
+  it("rejects slugs that aren't simple names (path-traversal guard)", async () => {
+    const saved = await saveAtmosphereMusic("../escape", Buffer.from("x"));
+    expect(saved).toBe(false);
+    expect(await readAtmosphereMusic("../escape")).toBeNull();
+  });
+});

src/lib/ai/atmosphereMusicStore.ts

@@ -0,0 +1,51 @@
+import "server-only";
+
+import path from "node:path";
+import fs from "node:fs/promises";
+import { Buffer } from "node:buffer";
+
+/**
+ * Disk cache for generated per-world atmosphere music (ElevenLabs Music),
+ * mirroring the SFX store: one file per <world>, generated lazily on first
+ * request by /api/music/[world]/atmosphere and immutable afterwards.
+ */
+
+function getAtmosphereMusicStoreDir() {
+  return (
+    process.env.A2UI_ATMOSPHERE_MUSIC_DIR ?? path.join(process.cwd(), ".data", "atmosphere-music")
+  );
+}
+
+/** Only allow simple slug names so the path can't escape the store dir. */
+function isSafeSlug(value: string): boolean {
+  return /^[a-z0-9-]{1,64}$/.test(value);
+}
+
+function atmosphereMusicFilePath(world: string): string | null {
+  if (!isSafeSlug(world)) return null;
+  return path.join(getAtmosphereMusicStoreDir(), `${world}.mp3`);
+}
+
+export async function readAtmosphereMusic(
+  world: string
+): Promise<{ data: Buffer; contentType: string } | null> {
+  const filePath = atmosphereMusicFilePath(world);
+  if (!filePath) return null;
+  const data = await fs.readFile(filePath).catch(() => null);
+  if (!data) return null;
+  return { data, contentType: "audio/mpeg" };
+}
+
+export async function saveAtmosphereMusic(world: string, data: Buffer): Promise<boolean> {
+  const filePath = atmosphereMusicFilePath(world);
+  if (!filePath) return false;
+  await fs.mkdir(getAtmosphereMusicStoreDir(), { recursive: true });
+  await fs.writeFile(filePath, data);
+  return true;
+}
+
+export async function deleteAtmosphereMusic(world: string): Promise<void> {
+  const filePath = atmosphereMusicFilePath(world);
+  if (!filePath) return;
+  await fs.unlink(filePath).catch(() => null);
+}