vibeaudio 0.4.0 → 0.6.1

package/src/hooks.js

@@ -20,10 +20,12 @@ const { AudioPlayer } = require("./player");
 const STATE_DIR = path.join(os.homedir(), ".vibeaudio");
 const PID_FILE = path.join(STATE_DIR, "daemon.pid");
 const INTENSITY_FILE = path.join(STATE_DIR, "intensity");
-// Present while the music is paused mid-turn; holds what will resume it.
-const WAITING_FILE = path.join(STATE_DIR, "waiting");
-// The turn the music belongs to: its session, and where its transcript began.
-const TURN_FILE = path.join(STATE_DIR, "turn.json");
+// One file per agent session with a turn in flight. The music plays while any of
+// them is working; each holds where its transcript began and, while paused for
+// the user, what will resume it.
+const SESSIONS_DIR = path.join(STATE_DIR, "sessions");
+// Payloads that name no session share this one slot.
+const ANON_SESSION = "anon";
 const CLI_ENTRY = path.join(__dirname, "..", "bin", "vibeaudio.js");
 
 /**
@@ -343,29 +345,59 @@ function readPid() {
  * ponytail: posix only. Windows has no cheap command-line lookup, so the pid
  * is trusted there as before; revisit if hooks see real Windows use.
  */
-function isOurDaemon(pid) {
-  if (process.platform === "win32") return true;
+function daemonArgv(pid) {
+  if (process.platform === "win32") return null;
   try {
-    const out = execFileSync("ps", ["-p", String(pid), "-o", "args="], {
+    return execFileSync("ps", ["-p", String(pid), "-o", "args="], {
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"]
     });
-    return out.includes("vibeaudio") && out.includes("--daemon");
   } catch (e) {
-    return false; // No such process, or ps unavailable - either way, do not kill.
+    return null; // No such process, or ps unavailable.
   }
 }
 
+function isOurDaemon(pid) {
+  if (process.platform === "win32") return true;
+  const out = daemonArgv(pid);
+  // Failing closed: no argv means no kill.
+  return out !== null && out.includes("vibeaudio") && out.includes("--daemon");
+}
+
+/**
+ * What the background player is playing right now, or null if nothing is.
+ *
+ * Read from the daemon's own command line rather than a file it would have to
+ * keep in step - spawnDaemon() puts the settings there already, and a process
+ * that dies without cleanup cannot leave a stale answer behind. It is the
+ * settings *in flight*, which is the question a running daemon raises: a
+ * genre saved a moment ago does not reach it until the next prompt.
+ */
+function daemonPlaying() {
+  const pid = readPid();
+  if (pid === null || !isOurDaemon(pid)) return null;
+
+  const argv = daemonArgv(pid) || "";
+  const genre = /--genre (\S+)/.exec(argv);
+  const volume = /--volume (\d+)/.exec(argv);
+  return {
+    pid,
+    genre: genre ? genre[1] : null,
+    volume: volume ? Number(volume[1]) : null,
+    reactive: /--reactive/.test(argv)
+  };
+}
+
 /**
- * `pause` keeps the turn's state (what resumes it, whose it is): only the hooks
- * pausing mid-turn pass it. Every other stop (new prompt, turn end, --stop,
- * uninstall) ends the turn, or a later tool call would resume music nobody is
- * waiting for.
+ * Stops the player. `keepSessions` leaves the session files alone: the hooks
+ * use it because they decide per session what is still going on. Every other
+ * stop (--stop, --mute, uninstall) ends everything, or a later tool call would
+ * resume music nobody is waiting for.
  */
-function stopDaemon({ pause = false } = {}) {
+function stopDaemon({ keepSessions = false } = {}) {
   const pid = readPid();
   fs.rmSync(PID_FILE, { force: true });
-  if (!pause) endTurnState();
+  if (!keepSessions) fs.rmSync(SESSIONS_DIR, { recursive: true, force: true });
   if (pid === null || !isOurDaemon(pid)) return false;
 
   try {
@@ -376,11 +408,6 @@ function stopDaemon({ pause = false } = {}) {
   }
 }
 
-function endTurnState() {
-  fs.rmSync(WAITING_FILE, { force: true });
-  fs.rmSync(TURN_FILE, { force: true });
-}
-
 function fileSize(file) {
   try {
     return fs.statSync(file).size;
@@ -400,14 +427,60 @@ function newTurn(raw) {
   return { session: String(payload.session_id || ""), transcript, offset: transcript ? fileSize(transcript) : 0 };
 }
 
-function readTurn() {
+// The id ends up in a file name.
+function sessionId(id) {
+  return String(id || ANON_SESSION).replace(/[^\w.-]/g, "_").slice(0, 100);
+}
+
+function sessionFile(id) {
+  return path.join(SESSIONS_DIR, `${id}.json`);
+}
+
+function readSession(id) {
   try {
-    return JSON.parse(fs.readFileSync(TURN_FILE, "utf8"));
+    return JSON.parse(fs.readFileSync(sessionFile(id), "utf8"));
   } catch (e) {
     return null;
   }
 }
 
+// Written beside the target and renamed into place: the daemon lists this
+// directory every poll and must never read half a file.
+function writeSession(id, data) {
+  fs.mkdirSync(SESSIONS_DIR, { recursive: true });
+  const tmp = `${sessionFile(id)}.${process.pid}.tmp`;
+  fs.writeFileSync(tmp, JSON.stringify({ ...data, ts: Date.now() }));
+  fs.renameSync(tmp, sessionFile(id));
+}
+
+/**
+ * Every session with a turn in flight. One that has not been touched for
+ * MAX_DAEMON_MS is a crashed agent - it never sent Stop - and is dropped here,
+ * the same ceiling the daemon itself stops at.
+ */
+function listSessions() {
+  let names;
+  try {
+    names = fs.readdirSync(SESSIONS_DIR);
+  } catch (e) {
+    return [];
+  }
+  const now = Date.now();
+  const sessions = [];
+  for (const name of names) {
+    if (!name.endsWith(".json")) continue;
+    const id = name.slice(0, -".json".length);
+    const data = readSession(id);
+    if (!data) continue;
+    if (now - (data.ts || 0) > MAX_DAEMON_MS) fs.rmSync(sessionFile(id), { force: true });
+    else sessions.push({ id, ...data });
+  }
+  return sessions;
+}
+
+// Working, as opposed to paused for the user.
+const working = (sessions) => sessions.filter((s) => s.waiting == null);
+
 // Claude Code's entry for Esc / the stop button: a user message whose text is
 // "[Request interrupted by user]" or "... for tool use]".
 const INTERRUPT_MARK = "[Request interrupted by user";
@@ -466,29 +539,47 @@ function interruptWatcher(transcript, offset) {
 const INTERRUPT_POLL_MS = 500;
 
 /**
- * Internal mode: holds the audio open until told to stop. The player's own
- * loop timer keeps the event loop alive.
+ * Internal mode: plays while any session is working. The player's own loop
+ * timer keeps the event loop alive.
  */
 function runDaemon(genre, volume, { reactive = false } = {}) {
-  const turn = readTurn();
-  const interrupted = turn && turn.transcript ? interruptWatcher(turn.transcript, turn.offset) : null;
+  const watchers = new Map(); // session id -> its transcript poll
+
+  // Drops sessions whose transcript shows an interrupt (Esc fires no hook, so
+  // this is the only way to learn of one) and says whether any is still working.
+  const sweep = () => {
+    const sessions = listSessions();
+    for (const id of watchers.keys()) if (!sessions.some((s) => s.id === id)) watchers.delete(id);
+    for (const s of sessions) {
+      if (!s.transcript) continue;
+      // Built from the offset taken at the prompt, so a daemon respawned mid-turn
+      // still sees an interrupt that came before it.
+      if (!watchers.has(s.id)) watchers.set(s.id, interruptWatcher(s.transcript, s.offset));
+      if (watchers.get(s.id)()) {
+        fs.rmSync(sessionFile(s.id), { force: true });
+        watchers.delete(s.id);
+      }
+    }
+    return working(listSessions()).length > 0;
+  };
 
   // Silent, like Ctrl+C in the wrapper: an interrupt is never reported as done.
-  const endInterrupted = () => {
+  const endIdle = () => {
     if (readPid() === process.pid) {
       fs.rmSync(PID_FILE, { force: true });
-      endTurnState();
       fs.rmSync(INTENSITY_FILE, { force: true });
     }
     process.exit(0);
   };
-  // Already interrupted before this daemon started - a resume respawned by the
-  // PostToolUse that an interrupted tool still fires.
-  if (interrupted && interrupted()) endInterrupted();
+  if (!sweep()) endIdle(); // Already interrupted before this daemon started.
 
   const player = new AudioPlayer();
   const started = player.start(genre, volume, {
-    intensity: reactive ? readIntensity : null
+    intensity: reactive ? readIntensity : null,
+    // The same piece with more of it, as time escalation already does: two
+    // sessions working is tier 2 at least, three or more is tier 3. Read at
+    // each loop boundary, so it lands cleanly and eases off as they finish.
+    minTier: () => Math.min(3, working(listSessions()).length)
   });
   if (!started) process.exit(0);
 
@@ -501,32 +592,46 @@ function runDaemon(genre, volume, { reactive = false } = {}) {
   process.on("SIGINT", shutdown);
   setTimeout(shutdown, MAX_DAEMON_MS);
 
-  if (interrupted) {
-    setInterval(() => {
-      if (!interrupted()) return;
-      player.stop({ playChime: false });
-      endInterrupted();
-    }, INTERRUPT_POLL_MS);
-  }
+  setInterval(() => {
+    if (sweep()) return;
+    player.stop({ playChime: false });
+    endIdle();
+  }, INTERRUPT_POLL_MS);
 }
 
-function hookStart(genre, volume, { reactive = false, turn = null } = {}) {
-  stopDaemon(); // Single instance: a new prompt replaces the previous run
-  fs.mkdirSync(STATE_DIR, { recursive: true });
-  fs.rmSync(INTENSITY_FILE, { force: true }); // Don't inherit the last prompt's activity
-  // Before the spawn: the daemon reads it on startup.
-  if (turn) fs.writeFileSync(TURN_FILE, JSON.stringify(turn));
+function daemonRunning() {
+  const pid = readPid();
+  return pid !== null && isOurDaemon(pid);
+}
 
+function spawnDaemon(genre, volume, reactive) {
   const args = [CLI_ENTRY, "--daemon", "--genre", genre, "--volume", String(Math.round(volume * 100))];
   if (reactive) args.push("--reactive");
 
   const child = spawn(process.execPath, args, { detached: true, stdio: "ignore" });
   child.unref();
 
+  fs.mkdirSync(STATE_DIR, { recursive: true });
   fs.writeFileSync(PID_FILE, String(child.pid));
   return child.pid;
 }
 
+/**
+ * A prompt. With no other session working this replaces the player, as it
+ * always did, so a genre change lands on the next prompt. With one working the
+ * music carries on: restarting it would cut every other session's stream.
+ */
+function hookStart(genre, volume, { reactive = false, turn = null } = {}) {
+  const id = sessionId(turn && turn.session);
+  // Before the spawn: the daemon reads it on startup.
+  writeSession(id, { transcript: (turn && turn.transcript) || "", offset: (turn && turn.offset) || 0, waiting: null });
+  if (working(listSessions()).some((s) => s.id !== id) && daemonRunning()) return readPid();
+
+  stopDaemon({ keepSessions: true });
+  fs.rmSync(INTENSITY_FILE, { force: true }); // Don't inherit the last prompt's activity
+  return spawnDaemon(genre, volume, reactive);
+}
+
 /**
  * What the agent's stop event says about how the turn ended. Cursor reports
  * it in `status` ("completed", "aborted" or "error"). Claude Code's Stop
@@ -574,27 +679,25 @@ function readPayload(done, timeoutMs = 500) {
   setTimeout(finish, timeoutMs).unref();
 }
 
-function hookStop({ outcome = "success", volume = 0.4, chimeVolume = null, noChime = false } = {}) {
-  // Read before stopDaemon clears it. A turn that ends while paused for the
-  // user - a denied tool that nothing resumed after - still finished.
-  const wasWaiting = fs.existsSync(WAITING_FILE);
-  const wasPlaying = stopDaemon();
-  fs.rmSync(INTENSITY_FILE, { force: true });
-  if (!(wasPlaying || wasWaiting) || noChime) return false;
-
-  // Chime plays in this short-lived hook process, after the daemon is gone.
+function hookStop({ outcome = "success", volume = 0.4, chimeVolume = null, noChime = false, raw = "" } = {}) {
+  const id = sessionId(parsePayload(raw).session_id);
+  // A turn that ends while paused for the user - a denied tool that nothing
+  // resumed after - still finished, so its session counts either way.
+  const tracked = readSession(id) !== null;
+  fs.rmSync(sessionFile(id), { force: true });
+
+  // The music is every working session's, so it ends with the last of them.
+  // Everyone else's carries on, and this session still gets its own chime.
+  const others = working(listSessions()).length > 0;
+  const wasPlaying = others ? false : stopDaemon({ keepSessions: true });
+  if (!others) fs.rmSync(INTENSITY_FILE, { force: true });
+  if (!(tracked || wasPlaying) || noChime) return false;
+
+  // Chime plays in this short-lived hook process.
   new AudioPlayer().stop({ playChime: true, outcome, volume, chimeVolume });
   return true;
 }
 
-function readWaiting() {
-  try {
-    return fs.readFileSync(WAITING_FILE, "utf8");
-  } catch (e) {
-    return null;
-  }
-}
-
 /**
  * What a wait is waiting for, and what ends it: the tool's name for a
  * permission dialog and its PostToolUse, the server's name for an MCP
@@ -618,11 +721,12 @@ const WAIT_NOTIFICATIONS = new Set([
  * The agent is blocked on the user (a permission dialog, a question, a plan to
  * approve, an MCP server asking for input). Music that keeps playing says
  * "still working", which is the one thing that is not true, so it stops and
- * the attention chime asks instead.
+ * the attention chime asks instead - unless another session is still working,
+ * whose music is not this dialog's to end.
  *
- * Only while music is playing: after the turn has ended there is nobody to
- * interrupt, and a second dialog while already waiting keeps the first wait
- * rather than chiming twice.
+ * Only for a turn in flight: after it has ended there is nobody to interrupt,
+ * and a second dialog while already waiting keeps the first wait rather than
+ * chiming twice.
  *
  * The chime is detached: the agent waits on this hook before showing the
  * dialog, and a chime played to completion here held it back for its length.
@@ -632,8 +736,12 @@ function hookWait(raw, { volume = 0.4, chimeVolume = null, noChime = false } = {
   const type = payload.notification_type ?? payload.notificationType;
   if (type !== undefined && !WAIT_NOTIFICATIONS.has(String(type))) return false;
 
-  if (!stopDaemon({ pause: true })) return false;
-  fs.writeFileSync(WAITING_FILE, waitKey(raw));
+  const id = sessionId(payload.session_id);
+  const session = readSession(id);
+  if (!session || session.waiting != null) return false;
+
+  writeSession(id, { ...session, waiting: waitKey(raw) });
+  if (working(listSessions()).length === 0) stopDaemon({ keepSessions: true });
   if (!noChime) new AudioPlayer().stop({ playChime: true, outcome: "attention", volume, chimeVolume, detach: true });
   return true;
 }
@@ -643,22 +751,24 @@ function hookWait(raw, { volume = 0.4, chimeVolume = null, noChime = false } = {
  * itself, so this is the first signal that work carries on after one - resume,
  * if it is the one being waited for.
  *
- * The turn is carried over rather than started afresh, so the new daemon keeps
- * watching the transcript from the prompt. An approved tool interrupted with
- * Esc still fires this PostToolUse, and must not bring the music back.
+ * The session keeps its transcript offset from the prompt, so an approved tool
+ * interrupted with Esc, which still fires this PostToolUse, is seen by the
+ * daemon and must not bring the music back.
  *
  * ponytail: matching by name means two same-named tools in one parallel batch,
  * one needing approval, can resume early - after the chime already did its
  * job. Match on tool_input as well if that ever shows up in practice.
  */
 function hookResume(raw, genre, volume, { reactive = false } = {}) {
-  const waitingFor = readWaiting();
-  if (waitingFor === null) return false; // Not waiting - the common case, on every tool call.
+  const id = sessionId(parsePayload(raw).session_id);
+  const session = readSession(id);
+  if (!session || session.waiting == null) return false; // Not waiting - the common case, on every tool call.
   // An empty key is a wait that named nothing (a Notification): the next tool
   // to finish is the first sign of work carrying on.
-  if (waitingFor !== "" && waitingFor !== waitKey(raw)) return false;
+  if (session.waiting !== "" && session.waiting !== waitKey(raw)) return false;
 
-  hookStart(genre, volume, { reactive, turn: readTurn() || newTurn(raw) });
+  writeSession(id, { ...session, waiting: null });
+  if (!daemonRunning()) spawnDaemon(genre, volume, reactive);
   return true;
 }
 
@@ -666,18 +776,20 @@ function hookResume(raw, genre, volume, { reactive = false } = {}) {
  * The agent's session is over (quit, /clear, logout). A turn cut off by it
  * never reaches Stop. Silent: nothing finished.
  *
- * Only the session that started the music may end it. SessionEnd also fires
- * for idle sessions, and one terminal closing must not silence another that is
- * mid-turn. Fails closed: with no recorded session there is no proof the music
- * is this session's, and the MAX_DAEMON_MS ceiling still applies.
+ * Only that session's own turn ends, so one terminal closing cannot silence
+ * another that is mid-turn. Fails closed on an unknown session: with none on
+ * record there is nothing of its to end, and the MAX_DAEMON_MS ceiling still
+ * applies.
  */
 function hookEnd(raw) {
-  const turn = readTurn();
-  const owner = turn && turn.session;
-  if (!owner || owner !== String(parsePayload(raw).session_id || "")) return false;
+  const id = sessionId(parsePayload(raw).session_id);
+  if (!readSession(id)) return false;
 
-  stopDaemon();
-  fs.rmSync(INTENSITY_FILE, { force: true });
+  fs.rmSync(sessionFile(id), { force: true });
+  if (working(listSessions()).length === 0) {
+    stopDaemon({ keepSessions: true });
+    fs.rmSync(INTENSITY_FILE, { force: true });
+  }
   return true;
 }
 
@@ -699,13 +811,24 @@ function shellQuote(value) {
   return `'${String(value).replace(/'/g, "'\\''")}'`;
 }
 
+/**
+ * Genre and volume are deliberately NOT written into the command line.
+ *
+ * They used to be, and that is what made "change the genre" mean "re-run the
+ * installer": a value frozen into seven hook entries at install time, which no
+ * later `vibe --genre jazz` and no exported variable could reach. Each hook
+ * fires as a fresh process and parses its own arguments, so leaving them out
+ * means it reads the saved config (see loadConfig() in player.js) on every
+ * prompt - and a genre change lands on the next one, with nothing reinstalled.
+ *
+ * `--reactive` stays, because it is not a setting the hook reads: it decides
+ * which hooks exist at all, and the PreToolUse entry is written or removed to
+ * match. A daemon respawned by a resume has to know it too.
+ */
 function hookCommand(flag, genre, volume, reactive = false) {
   const base = `${shellQuote(process.execPath)} ${shellQuote(CLI_ENTRY)} ${flag}`;
-  // Resuming respawns the daemon, so it needs the same settings as starting.
-  if (flag !== "--hook-start" && flag !== "--hook-resume") return base;
-
-  const start = `${base} --genre ${genre} --volume ${Math.round(volume * 100)}`;
-  return reactive ? `${start} --reactive` : start;
+  if (!reactive) return base;
+  return flag === "--hook-start" || flag === "--hook-resume" ? `${base} --reactive` : base;
 }
 
 const VIBE_HOOK_FLAG = /--hook-(start|stop|tool|wait|resume|end)\b/;
@@ -891,10 +1014,10 @@ single short sentence. Do nothing else.
 - \`mute\` or \`mute <minutes>\`: \`${cli} --mute <minutes>\`
 - \`unmute\`: \`${cli} --unmute\`
 - \`stop\`: \`${cli} --stop\`
-- \`genre <name>\` or \`volume <5-100>\`: first run \`${cli} --status\` and read
-  Claude Code's current genre, volume, and whether it says "reactive". Then run
-  \`${cli} --install-hooks --tools claude --genre <genre> --volume <volume>\`,
-  adding \`--reactive\` if it was reactive, and changing only what was asked.
+- \`genre <name>\`: \`${cli} --genre <name>\`
+- \`volume <5-100>\`: \`${cli} --volume <n>\`
+  Both save the user's default and reach the hooks on the next prompt - there
+  is nothing to reinstall, so do not run --install-hooks for these.
   Genres: lofi, synthwave, 8bit, electronic, jazz, zen, piano, drone, random.
 
 For anything else, show the user the list above instead of running a command.
@@ -964,6 +1087,7 @@ module.exports = {
   readIntensity,
   stopDaemon,
   isOurDaemon,
+  daemonPlaying,
   installHooks,
   ephemeralInstallReason,
   uninstallHooks,

package/src/interactive.js

@@ -52,7 +52,48 @@ const GENRES = [
   { name: "🎲 Shuffle / Random", desc: "Picks a surprise vibe each time", id: "random" }
 ];
 
-function selectMenu(title, items, renderItem) {
+
+/**
+ * One loop of a genre, started from inside the menu and replaced on each
+ * press. Non-blocking: the menu stays interactive while it plays, so you can
+ * page through the list and hear each one.
+ *
+ * The process is module-level rather than per-menu because there is only ever
+ * one pair of speakers - a second press has to silence the first, or two
+ * genres play over each other.
+ */
+let previewChild = null;
+
+function stopPreview() {
+  if (!previewChild) return;
+  try {
+    previewChild.kill();
+  } catch (e) {
+    // Already gone - the loop ended on its own.
+  }
+  previewChild = null;
+}
+
+function playPreview(genreId) {
+  const { spawn } = require("child_process");
+  const { detectPlayer, getAudioPath, resolveGenre, normalizeVolume, loadConfig, playbackDisabled } = require("./player");
+
+  stopPreview();
+  // A muted user pressing "p" is asking to hear something, the same as
+  // `--preview` is - but a mute set for a call should still hold. Silence is
+  // the safe read, and --status says why.
+  if (playbackDisabled()) return;
+
+  const backend = detectPlayer();
+  if (!backend) return;
+
+  const volume = normalizeVolume(loadConfig().volume, 0.4);
+  const file = getAudioPath(resolveGenre(genreId), 2);
+  previewChild = spawn(backend.cmd, backend.args(file, volume), { stdio: "ignore" });
+  previewChild.on("error", () => { previewChild = null; });
+}
+
+function selectMenu(title, items, renderItem, { onPreview = null } = {}) {
   return new Promise((resolve) => {
     let selected = 0;
     const stdin = process.stdin;
@@ -92,6 +133,15 @@ function selectMenu(title, items, renderItem) {
         process.exit(0);
       }
 
+      // Auditioning is the whole reason the genre list is hard to choose from:
+      // nine names and a one-line description each, and no way to hear any of
+      // them without leaving the menu. A loop renders in ~150ms, so this is
+      // just a keypress.
+      if (onPreview && (key === "p" || key === "P")) {
+        onPreview(items[selected]);
+        return;
+      }
+
       if (key === "\u001b[A") {
         // Up arrow
         selected = (selected - 1 + items.length) % items.length;
@@ -119,6 +169,7 @@ function selectMenu(title, items, renderItem) {
     }
 
     function cleanup() {
+      if (onPreview) stopPreview();
       stdin.removeListener("data", onData);
       stdin.setRawMode(false);
       stdin.pause();
@@ -299,9 +350,10 @@ async function promptInteractive({ hooksInstalledFor = () => false } = {}) {
 
   // 3. Select Music Genre
   const selectedGenre = await selectMenu(
-    "Choose your sound vibe:",
+    "Choose your sound vibe:  \x1b[0m\x1b[90m(press p to hear the highlighted one)\x1b[0m",
     GENRES,
-    (item, num) => `${num}. ${item.name} \x1b[90m— ${item.desc}\x1b[0m`
+    (item, num) => `${num}. ${item.name} \x1b[90m— ${item.desc}\x1b[0m`,
+    { onPreview: (item) => playPreview(item.id) }
   );
 
   // 4. Select Volume Preset
@@ -335,4 +387,4 @@ async function promptInteractive({ hooksInstalledFor = () => false } = {}) {
   };
 }
 
-module.exports = { promptInteractive, tokenizeCommand, isInstalled, hookTargetOf, AI_TOOLS };
+module.exports = { promptInteractive, tokenizeCommand, isInstalled, hookTargetOf, playPreview, stopPreview, AI_TOOLS };

package/src/mcp.js

@@ -6,7 +6,7 @@
  */
 
 const readline = require("readline");
-const { AudioPlayer, AVAILABLE_GENRES, normalizeVolume, playbackDisabled, isKnownGenre } = require("./player");
+const { AudioPlayer, AVAILABLE_GENRES, normalizeVolume, playbackDisabled, isKnownGenre, loadConfig } = require("./player");
 const pkg = require("../package.json");
 
 // A desktop client that crashes never sends vibe_stop, so playback needs its
@@ -132,7 +132,12 @@ function handleMessage(player, msg) {
     const { name, arguments: args = {} } = params || {};
 
     if (name === "vibe_play") {
-      const requested = args.genre || process.env.VIBE_GENRE || "lofi";
+      // Same precedence as the CLI: what the model asked for, then the
+      // environment, then the user's saved default, then lofi. Reading the
+      // saved file here is what makes `vibe --genre jazz` mean jazz in a
+      // desktop client too, rather than only in the terminal.
+      const saved = loadConfig();
+      const requested = args.genre || process.env.VIBE_GENRE || saved.genre || "lofi";
       // An unknown genre already fell back to lofi inside the generator, but
       // player.genre kept the name nobody implements - so the model told the
       // user it was playing something that does not exist.
@@ -140,7 +145,8 @@ function handleMessage(player, msg) {
       // Both the tool argument and the env default go through the same parser
       // as the CLI, so a mistyped VIBE_VOLUME falls back instead of reaching
       // the player as NaN.
-      const volume = normalizeVolume(args.volume, normalizeVolume(process.env.VIBE_VOLUME, 0.4));
+      const volume = normalizeVolume(args.volume,
+        normalizeVolume(process.env.VIBE_VOLUME, normalizeVolume(saved.volume, 0.4)));
 
       const started = player.start(genre, volume, { maxDurationMs: MAX_PLAYBACK_MS });
       // start() returns false for three unrelated reasons, and the model