@audiofool/moondog 0.3.0-beta.1 → 0.3.0-beta.3

package/README.md

@@ -4,7 +4,7 @@
 
 <h1 align="center">Moondog</h1>
 
-<p align="center">Source candidate 0.3.0-beta.1</p>
+<p align="center">Source candidate 0.3.0-beta.3</p>
 
 <p align="center"><strong>A listening room that shows its work.</strong></p>
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@audiofool/moondog",
-  "version": "0.3.0-beta.1",
+  "version": "0.3.0-beta.3",
   "type": "module",
   "description": "Local-first personal AI music agent.",
   "license": "Apache-2.0",

package/scripts/moondog.mjs

@@ -34,6 +34,7 @@ import { runListenerProfileCommand, savedProfileActions } from "../src/surfaces/
 import { createWebResearch } from "../src/integrations/web/web-research.mjs";
 import { runWebCommand } from "../src/surfaces/cli/web-command.mjs";
 import { openSpotifyConnection } from "../src/integrations/spotify/connection.mjs";
+import { preferredIdleDevice, thisComputerName } from "../src/integrations/spotify/service.mjs";
 import {
   openSpotifyResolutionCache,
 } from "../src/integrations/spotify/resolution-cache.mjs";
@@ -54,6 +55,7 @@ import { createAppleMusicCatalog } from "../src/integrations/apple-music/catalog
 import { createTerminalPreviewPlayer } from "../src/integrations/apple-music/terminal-preview-player.mjs";
 import { createNeteasePlayer } from "../src/integrations/netease/ncm-cli-player.mjs";
 import { createAtmosphereStream, createLocalGenerator } from "../src/integrations/stable-audio/local-generator.mjs";
+import { createStableAudioSetup } from "../src/integrations/stable-audio/setup.mjs";
 import { createMusicAppPlayer } from "../src/integrations/apple-music/music-app.mjs";
 import {
   createOpenMusicSimilarity,
@@ -452,6 +454,76 @@ async function emitTasteprintArtifact(
   return result;
 }
 
+// While the terminal's stream runs, the Music app is read this often. Only a change from not playing
+// to playing ends the stream, and only in a read that began after the stream last changed and past its
+// start: the song the first track pauses keeps playing while that track is made.
+const STREAM_MUSIC_APP_MS = 5_000;
+function watchMusicAppForStream(stream, { musicApp, interval = STREAM_MUSIC_APP_MS }) {
+  if (musicApp?.available !== true) return () => {};
+  let timer = null;
+  let reading = false;
+  let playing = null;
+  let phase = null;
+  let changedAt = 0;
+  const read = async () => {
+    if (reading) return;
+    reading = true;
+    const began = Date.now();
+    try {
+      const now = await musicApp.nowPlaying().catch(() => null);
+      const view = stream.view();
+      if (!view || began <= changedAt) return;
+      const playingNow = now?.state === "playing";
+      if (playingNow && playing === false && view.phase !== "starting") stream.stop("other_music");
+      playing = playingNow;
+    } finally {
+      reading = false;
+    }
+  };
+  const unsubscribe = stream.subscribe(({ view }) => {
+    changedAt = Date.now();
+    // The first track just paused the Music app, so playing at a later read is news.
+    if (phase === "starting" && view && view.phase !== "starting") playing = false;
+    phase = view?.phase ?? null;
+    if (view && !timer) {
+      playing = null;
+      timer = setInterval(() => void read(), interval);
+      timer.unref?.();
+    } else if (!view && timer) {
+      clearInterval(timer);
+      timer = null;
+    }
+  });
+  return () => {
+    unsubscribe();
+    clearInterval(timer);
+    timer = null;
+  };
+}
+
+// Whether a /spotify command starts Spotify on this Mac: play on the device it resumes on (the active one,
+// or with none active the one it would pick), or a move onto this Mac with --play or while Spotify plays (a
+// move keeps playing what plays). A command its own checks refuse, or reads that fail, start nothing here.
+async function spotifyStartsHere(application, args, { signal } = {}) {
+  if (!application.spotifyReady?.()) return false;
+  // A trailing --json changes only how the result is written.
+  if (args.at(-1) === "--json") args = args.slice(0, -1);
+  const play = args[0] === "play" && args.length <= 2;
+  const transfer = args[0] === "transfer" && args.length >= 2 && args.length <= 3 && (args.length === 2 || args[2] === "--play");
+  if (!play && !transfer) return false;
+  const service = application.requireSpotifyService();
+  const [listed, player] = await Promise.all([service.devices({ signal }).catch(() => null), service.currentPlayer({ signal }).catch(() => null)]);
+  const devices = listed?.devices ?? [];
+  if (transfer) {
+    const device = devices.find((entry) => entry.id === args[1]);
+    const playing = player?.state === "available" && player.is_playing === true;
+    return Boolean(device) && application.spotifyOnThisMac(device) && (args[2] === "--play" || playing);
+  }
+  const active = player?.device?.is_active === true ? player.device : devices.find((device) => device.is_active === true);
+  const device = active ?? preferredIdleDevice(devices, { thisComputer: await thisComputerName() });
+  return Boolean(device) && application.spotifyOnThisMac(device);
+}
+
 async function main() {
   const updater = createApplicationUpdater();
   const argv = process.argv.slice(2);
@@ -851,10 +923,14 @@ async function main() {
   const neteasePlayer = createNeteasePlayer();
   const playbackService = await resolvePlaybackService();
   if (playbackService === "netease") await neteasePlayer.check();
-  // Moondog makes music on this Mac with the listener's own Stable Audio 3 once they turn it on, in a
-  // room that can play what it makes. The terminal and the window each keep one generator, so each
-  // makes one track at a time; a choice saved on one side is checked again on the other.
+  // Moondog makes music on this Mac with Stable Audio 3 once the listener turns it on, in a room
+  // that can play what it makes: Moondog's own install, downloaded when they ask, or their folder.
+  // The terminal and the window each keep one generator, so each makes one track at a time; a
+  // choice saved on one side is checked again on the other.
   const localGenerator = previewPlayer ? createLocalGenerator() : null;
+  const generationSetup = localGenerator ? createStableAudioSetup() : null;
+  // A model set up or removed, here or on the other side, is checked again.
+  const unwatchGenerationSetup = generationSetup?.subscribe(() => { void localGenerator.check().catch(() => {}); }) ?? (() => {});
   await localGenerator?.check();
   void localGenerator?.sweep().catch(() => {});
   const unwatchGeneration = localGenerator?.watch() ?? (() => {});
@@ -869,11 +945,15 @@ async function main() {
   const unobserveStream = atmosphereStream ? previewPlayer.subscribe?.((event) => atmosphereStream.observe(event)) : null;
   // Music making turned off, here or on the other surface, ends the stream.
   const unwatchStreamGeneration = atmosphereStream ? localGenerator.subscribe((status) => { if (status.state !== "ready") atmosphereStream.stop("generation_off"); }) : null;
+  // The window watches the Music app for its own stream; the terminal has no window, so while its
+  // stream runs it reads the Music app itself, and music the listener starts there ends the stream.
+  const unwatchStreamMusicApp = atmosphereStream && !host ? watchMusicAppForStream(atmosphereStream, { musicApp }) : null;
   const playbackSelection = createPlaybackSelection({ service: playbackService, save: writePlaybackPreference });
   // The terminal and the window each run this core on one playback.json. A service chosen on the
-  // other side reaches this side's picker and agents, and stops the previews this side plays.
+  // other side reaches this side's picker and agents, and stops the Apple Music songs this side plays.
+  // Moondog's stream is not a service: its made tracks play on.
   const unwatchPlayback = watchPlaybackPreference(playbackSelection, {
-    onChange: (service) => { if (service !== "apple_music") { atmosphereStream?.stop("service_change"); previewPlayer?.stop?.(); } },
+    onChange: (service) => { if (service !== "apple_music" && previewPlayer?.holdsCatalogSongs?.() !== false) previewPlayer?.stop?.(); },
   });
   // The main application and every conversation the window opens beside it are built from
   // this one list, so they cannot drift apart. Each passes in what may change after launch:
@@ -1083,7 +1163,12 @@ async function main() {
         status: () => localGenerator.status(),
         check: () => localGenerator.check(),
         save: (settings) => localGenerator.save(settings),
+        // Uses an installed model of Moondog's own install.
+        use: async (model) => (generationSetup?.status()?.models?.[model]?.state === "ready"
+          ? localGenerator.save({ source: "managed", model }) : localGenerator.check()),
         subscribe: (listener) => localGenerator.subscribe(listener),
+        // Download, cancel and remove, shared by the window and the terminal.
+        setup: generationSetup,
       },
       // The room asks whether a Last.fm key is set, and saves one the listener pastes.
       lastfm: {
@@ -1167,6 +1252,9 @@ async function main() {
         return json ? `\`\`\`json\n${output.trim()}\n\`\`\`` : output.trim();
       },
       runSpotify: async (args, { signal, stderr } = {}) => {
+        // /spotify play, and a move onto this Mac that plays there, start Spotify here: the other players go
+        // quiet first. A command its own checks will refuse, or a move to another device, quiets nothing.
+        if (await spotifyStartsHere(application, args, { signal })) await application.quietOtherPlayers("spotify", { signal });
         let output = "";
         const capture = {
           write(value) {
@@ -1192,6 +1280,10 @@ async function main() {
   } finally {
     unwatchPlayback();
     unwatchGeneration();
+    unwatchGenerationSetup();
+    // A download or uv run this process owns would keep it alive after the room closes; it stops and
+    // resumes next time. One owned by the other window or terminal runs on.
+    await generationSetup?.close?.();
     // A made track still playing is stopped while the generator listens, so its outcome is kept.
     if (localGenerator) {
       previewPlayer?.stop?.();
@@ -1200,6 +1292,7 @@ async function main() {
     unobservePlayer?.();
     unobserveStream?.();
     unwatchStreamGeneration?.();
+    unwatchStreamMusicApp?.();
     atmosphereStream?.stop("closed");
     listeningUpkeep?.stop();
     lyrics?.close();

package/src/core/listening-now.mjs

@@ -1,11 +1,13 @@
-// What the listener plays right now, wherever it plays: the Music app on this Mac, Spotify on its
-// active device, or NetEase through ncm-cli, with the playlist, album or queue it plays from.
-// Two players rarely play at once. When they do, one that plays wins over a paused one, then the
-// listener's chosen service, then this order.
-export const LISTENING_ORDER = Object.freeze(["apple_music", "spotify", "netease"]);
+// What the listener plays right now, wherever it plays: Moondog's own player (the songs it played or
+// queued, the tracks it made, its stream), the Music app on this Mac, Spotify on its active device,
+// or NetEase through ncm-cli, with the playlist, album or queue it plays from.
+// Two players rarely play at once. When they do, one that plays wins over a paused one, then
+// Moondog's own player, which pauses the others when it starts, then the listener's chosen service,
+// then this order.
+export const LISTENING_ORDER = Object.freeze(["moondog", "apple_music", "spotify", "netease"]);
 
 export function activeListening(sources, chosen) {
-  const order = [...new Set([chosen, ...LISTENING_ORDER])];
+  const order = [...new Set(["moondog", chosen, ...LISTENING_ORDER])];
   const heard = sources.filter((source) => source.song && (source.state === "playing" || source.state === "paused"));
   return heard.sort((a, b) => (a.state === "playing" ? 0 : 1) - (b.state === "playing" ? 0 : 1) ||
     order.indexOf(a.service) - order.indexOf(b.service))[0] ?? null;
@@ -75,6 +77,21 @@ async function spotify(application, { signal }) {
   };
 }
 
+// Moondog's own player: Apple Music songs in the window or the terminal, and the tracks Moondog made.
+const madeBy = (track) => ({ title: track.title, artists: track.generated ? ["Moondog"] : track.artist_credit ? [track.artist_credit] : [] });
+function moondogPlayer(application) {
+  const now = application.musicPreviewPlayer.nowPlaying();
+  if (!now?.song?.title) return { state: "stopped" };
+  const kind = !now.song.generated ? "moondog_queue" : application.streamView?.() ? "moondog_stream" : "moondog_made";
+  return {
+    state: now.state,
+    player: "Moondog's own player",
+    song: madeBy(now.song),
+    from: { kind, name: null, tracks_total: now.count, position: now.position },
+    next: now.next.map(madeBy),
+  };
+}
+
 async function netease(application) {
   const now = await application.neteaseNowPlaying();
   if (now.state === "stopped" || !now.song) return { state: "stopped" };
@@ -91,6 +108,7 @@ async function netease(application) {
 /** Every player Moondog can read, the one the listener hears first: { active, sources }. */
 export async function readListeningNow(application, { signal } = {}) {
   const readers = [
+    typeof application.musicPreviewPlayer?.nowPlaying === "function" ? ["moondog", () => moondogPlayer(application)] : null,
     application.musicApp?.available ? ["apple_music", () => musicApp(application)] : null,
     application.spotifyReady() ? ["spotify", () => spotify(application, { signal })] : null,
     application.neteaseReady() ? ["netease", () => netease(application)] : null,
@@ -106,3 +124,54 @@ export async function readListeningNow(application, { signal } = {}) {
   const active = activeListening(sources, application.playbackService);
   return { active: active?.service ?? null, sources: active ? [active, ...sources.filter((source) => source !== active)] : sources };
 }
+
+// What Moondog's own player plays: the queue it was sent last, and where in it the player's own
+// events put it. The window and the terminal players keep one each, so the agent can read the songs
+// it played or queued, and the tracks it made, as it reads the Music app or Spotify.
+
+const entry = (track) => ({
+  title: String(track?.title ?? "").trim(),
+  artist_credit: String(track?.artist_credit ?? "").trim(),
+  ...(track?.generated === true ? { generated: true } : {}),
+});
+
+export function createPlayerNow() {
+  // null, or { tracks, index, state } where state is "loading", "playing" or "paused".
+  let queue = null;
+  return {
+    /** A new queue replaces the last one and starts from its first song. */
+    queued(tracks) {
+      const list = (Array.isArray(tracks) ? tracks : []).map(entry).filter((track) => track.title);
+      queue = list.length ? { tracks: list, index: 0, state: "loading" } : null;
+    },
+    /** A made track queued behind the last one, as Moondog's stream does. */
+    appended(track) {
+      const added = entry(track);
+      if (queue && added.title) queue.tracks.push(added);
+    },
+    /** One of the player's events: { type, position } moves it along; stopped empties it. */
+    observe(event) {
+      // The terminal's player announces each new queue with its songs; the window's does not.
+      if (event?.type === "queue" && Array.isArray(event.tracks)) { this.queued(event.tracks); return; }
+      if (!queue) return;
+      if (event?.type === "stopped") { queue = null; return; }
+      if (Number.isInteger(event?.position) && event.position >= 1 && event.position <= queue.tracks.length) queue.index = event.position - 1;
+      if (event?.type === "playing" || event?.type === "paused" || event?.type === "loading") queue.state = event.type;
+    },
+    clear() {
+      queue = null;
+    },
+    /** null when nothing is queued, or { state, song, position, count, next } with up to ten songs after it. */
+    read() {
+      if (!queue) return null;
+      return {
+        // A song still loading is the one the listener is about to hear.
+        state: queue.state === "paused" ? "paused" : "playing",
+        song: { ...queue.tracks[queue.index] },
+        position: queue.index + 1,
+        count: queue.tracks.length,
+        next: queue.tracks.slice(queue.index + 1, queue.index + 11).map((track) => ({ ...track })),
+      };
+    },
+  };
+}

package/src/core/moondog-application.mjs

@@ -563,7 +563,7 @@ export class MoondogApplication {
     const file = await this.localGenerator.trackFile(id);
     if (!file) throw Object.assign(new Error("That track was part of a stream, which keeps only its newest tracks' audio; its receipt is still here."), { code: "made_track_audio_not_kept" });
     // Playing one of Moondog's tracks again ends its stream, on every surface.
-    await this.#endStream("replaced");
+    const endedStream = await this.#endStream("replaced");
     const title = String(receipt.title ?? "");
     // Named means quoted, or the title with Moondog, as on every play path: an open request shares
     // words with the plain titles Moondog gives its records ("something for a rainy day").
@@ -571,7 +571,9 @@ export class MoondogApplication {
     await this.quietOtherPlayers("apple_music", { signal });
     // A reply stopped before the track starts plays nothing, and no replay is recorded.
     if (signal?.aborted) throw Object.assign(new Error("Nothing was played, because the reply was stopped."), { code: "generation_stopped" });
-    // Nothing waits between this check and the play; the replay is written once it plays.
+    // Nothing waits between this check and the play; the replay is written once it plays. The ended
+    // stream's track it cuts off, or its queued one that started meanwhile, says nothing about the listener.
+    if (endedStream) this.localGenerator.discard?.();
     this.localGenerator.restart?.(id);
     this.musicPreviewPlayer.playGenerated({ id, title, seconds: receipt.audio?.duration_seconds, file });
     if (!named) this.#noteGeneratedPlay({ id, title });
@@ -590,7 +592,7 @@ export class MoondogApplication {
       return { state: "not_made", reason: compiled.descriptors.length ? "needs_a_sound" : "no_traceable_descriptors", dropped: compiled.dropped };
     }
     const prompt = stableAudioPrompt(compiled);
-    await this.#endStream("replaced");
+    const endedStream = await this.#endStream("replaced");
     const made = await this.localGenerator.generate({ prompt, seconds, title: compiled.title, receipt }, { signal, onProgress });
     // A reply stopped as the track finished keeps the track, but plays nothing over what is on now.
     await this.quietOtherPlayers("apple_music", { signal });
@@ -598,6 +600,8 @@ export class MoondogApplication {
     const file = await this.localGenerator.trackFile(made.id);
     // A reply stopped while the track was made, or while the other players paused, keeps the track but plays nothing.
     if (signal?.aborted) throw Object.assign(new Error("The track was made but not played, because the reply was stopped."), { code: "generation_stopped" });
+    // The replaced stream's track it cuts off was stopped by Moondog, not left by the listener.
+    if (endedStream) this.localGenerator.discard?.();
     this.musicPreviewPlayer.playGenerated({ id: made.id, title: made.title, seconds: made.duration_seconds, file });
     this.#noteGeneratedPlay(made);
     return { state: "playing", track: { id: made.id, title: made.title, seconds: made.duration_seconds, seed: made.seed },
@@ -640,18 +644,29 @@ export class MoondogApplication {
     }
     await this.#endStream("replaced");
     // Other music pauses only once the first track exists, as for a single track.
-    const { made, prompt } = await this.atmosphereStream.start({ compiled, title: compiled.title, seconds, minutes, receipt },
-      { signal, onProgress, onTrack: (track) => this.#noteGeneratedPlay(track), beforePlay: () => this.quietOtherPlayers("apple_music", { signal }) });
+    let started;
+    try {
+      started = await this.atmosphereStream.start({ compiled, title: compiled.title, seconds, minutes, receipt },
+        { signal, onProgress, onTrack: (track) => this.#noteGeneratedPlay(track), beforePlay: () => this.quietOtherPlayers("apple_music", { signal }) });
+    } catch (error) {
+      // The listener turned it off while its first track was made: their choice, not a failure to retry.
+      if (error?.code === "generation_stopped" && error.ended === "asked" && !signal?.aborted) return { state: "not_made", reason: "stopped_by_listener" };
+      throw error;
+    }
+    const { made, prompt } = started;
     return { state: "streaming", minutes, track: { id: made.id, title: made.title, seconds: made.duration_seconds, seed: made.seed },
       prompt, shaped_by: compiled.descriptors, sources: tasteSources(compiled.descriptors), left_out: compiled.dropped,
       ...(compiled.bpm ? { bpm: compiled.bpm } : {}), elapsed_ms: made.elapsed_ms };
   }
 
   // A single track or a new stream takes over from a running stream, once its next track stops being made.
+  // The stream's track plays on until the new one starts, so nothing goes silent while that is made.
+  // Says whether a stream ended.
   async #endStream(reason) {
-    if (!this.atmosphereStream?.active?.()) return;
+    if (!this.atmosphereStream?.active?.()) return false;
     this.atmosphereStream.stop(reason);
     for (let waited = 0; this.localGenerator?.busy?.() && waited < 5_000; waited += 100) await delay(100);
+    return true;
   }
 
   stopStream() {
@@ -659,6 +674,21 @@ export class MoondogApplication {
     return stopped ? { state: "stopped", tracks_made: stopped.tracks_made } : { state: "not_running" };
   }
 
+  // What the window and the terminal show of the stream: { phase, started_at, ends_at, tracks_made }, or null.
+  streamView() {
+    return this.atmosphereStream?.view?.() ?? null;
+  }
+
+  // Each change of the stream, as { view, ended }; a host without a stream hears nothing.
+  subscribeStream(listener) {
+    return this.atmosphereStream?.subscribe?.(listener) ?? (() => {});
+  }
+
+  // Whether a Spotify device is this Mac, where its music and Moondog's would play over each other.
+  spotifyOnThisMac(device) {
+    return spotifyOnThisMac(device);
+  }
+
   // What the compiler may trace a descriptor to. Each cited finding is read from the saved reading.
   async #tasteContext({ descriptors, moment, request }) {
     const choices = this.domainServices?.listenerChoices?.()?.items ?? [];
@@ -708,10 +738,13 @@ export class MoondogApplication {
   async playNetease({ items, mode, intent } = {}) {
     const player = this.requireNetease();
     this.requireListenerAvoids();
-    if (mode !== "queue") await this.quietOtherPlayers("netease");
+    const quiet = () => this.quietOtherPlayers("netease");
+    if (mode !== "queue") await quiet();
     // A found song lists its artists; a song asked for by name has only the name it was asked by.
-    const receipt = await player.play({ items, mode, intent, allow: (song) => this.avoidAllows(Array.isArray(song.artists)
-      ? { title: song.title, artist_credit: song.artists.join(", "), artists: song.artists } : song) });
+    // A queue with nothing loaded starts its first song, and quiets the others just before.
+    const receipt = await player.play({ items, mode, intent, ...(mode === "queue" ? { beforePlay: quiet } : {}),
+      allow: (song) => this.avoidAllows(Array.isArray(song.artists)
+        ? { title: song.title, artist_credit: song.artists.join(", "), artists: song.artists } : song) });
     if (["playing", "queued"].includes(receipt?.mode)) {
       const songs = receipt.songs ?? [];
       const slots = this.#mixSlots(songs.map((song) => ({ title: song.title, artists: song.artists })));
@@ -726,8 +759,13 @@ export class MoondogApplication {
 
   async controlNetease({ action, positionSeconds } = {}) {
     const player = this.requireNetease();
+    const quiet = () => this.quietOtherPlayers("netease");
+    if (action === "resume") await quiet();
     if (action === "seek") await player.seek({ positionMs: Math.max(0, Number(positionSeconds) || 0) * 1000 });
-    else if (["pause", "resume", "next", "previous", "stop"].includes(action)) await player[action]();
+    // Next and previous start a song, so the other players go quiet just before; a refusal or a
+    // previous that only rewinds starts none.
+    else if (action === "next" || action === "previous") await player[action]({ beforePlay: quiet });
+    else if (["pause", "resume", "stop"].includes(action)) await player[action]();
     else throw Object.assign(new Error(`Unknown NetEase action: ${action}`), { code: "netease_failed" });
     return await player.nowPlaying();
   }
@@ -736,9 +774,10 @@ export class MoondogApplication {
     return this.requireNetease().nowPlaying();
   }
 
-  // Whether any player the listener uses can be read: the Music app, Spotify or NetEase.
+  // Whether any player the listener uses can be read: Moondog's own, the Music app, Spotify or NetEase.
   listeningReadable() {
-    return this.musicApp?.available === true || this.spotifyReady() || this.neteaseReady();
+    return typeof this.musicPreviewPlayer?.nowPlaying === "function" || this.musicApp?.available === true ||
+      this.spotifyReady() || this.neteaseReady();
   }
 
   // What the listener plays right now on any of them, and what it plays from (src/core/listening-now.mjs).
@@ -829,12 +868,13 @@ export class MoondogApplication {
     ]);
   }
 
-  // The service just left stops playing, so two services never play at once.
+  // The service just left stops playing, so two services never play at once. Moondog's stream is its
+  // own channel, not a service: its made tracks play on, and it ends only when a service song plays.
   async #stopPlaybackService(service) {
     try {
       if (service === "apple_music") {
-        this.atmosphereStream?.stop?.("service_change");
-        this.musicPreviewPlayer?.stop?.();
+        // Apple Music's songs in Moondog's player stop; a player that can't say what it holds stops, as before.
+        if (this.musicPreviewPlayer?.holdsCatalogSongs?.() !== false) this.musicPreviewPlayer?.stop?.();
         // The listener's own Music app too, when it plays.
         if ((await this.musicApp?.nowPlaying?.())?.state === "playing") await this.musicApp.pause();
       } else if (service === "netease" && this.neteasePlayer?.ready?.() === true) await this.neteasePlayer.stop();
@@ -2093,8 +2133,6 @@ export class MoondogApplication {
     this.requireSpotifyNonRemovalAction();
     const transaction = this.pendingPlaylistPromptTransaction;
     if (!transaction) throw spotifyResolutionError("spotify_queue_request_required", "Queueing runs inside a listener request.");
-    // An idle device starts the first song.
-    await this.quietOtherPlayers("spotify", { signal });
     // The model acts on the listener's words, as for a single queue entry. A parsed
     // count only sizes the batch; failing to parse a phrasing never blocks it.
     const intent = transaction.queueIntent ?? null;
@@ -2146,6 +2184,10 @@ export class MoondogApplication {
     const rest = new Set();
     while (album && queue.at(-1)?.album_uri === album && !rest.has(queue.at(-1).uri)) rest.add(queue.pop().uri);
     const seen = new Set([observed.currently_playing?.uri, ...queue.map(track => track.uri)].filter(Boolean));
+    // With nothing playing and nothing queued, Spotify has dropped what Moondog queued (its device
+    // went idle), so those songs were not heard: a new request may queue them again.
+    // A player that could not be read says nothing, so the songs stay held back.
+    if (!seen.size && player && player.is_playing !== true && !player.item) this.recentSimilarQueueUris.clear();
     for (const [uri, acceptedAt] of this.recentSimilarQueueUris) {
       if (Date.now() - acceptedAt > 15 * 60_000) this.recentSimilarQueueUris.delete(uri);
       else seen.add(uri);
@@ -3289,8 +3331,11 @@ export class MoondogApplication {
         const service = this.requireSpotifyService();
         target ??= await service.queueTarget({ ...(deviceId ? { deviceId } : {}) }, { signal });
         const device = target.deviceId ? { deviceId: target.deviceId } : {};
-        // Nothing is playing, so a queue entry has nowhere to go: start this song instead.
+        // Nothing is playing, so a queue entry has nowhere to go: start this song instead. That starts
+        // music, so the other players go quiet first; a queue behind a song already there starts none.
         const start = async () => {
+          await this.quietOtherPlayers("spotify", { signal });
+          signal?.throwIfAborted();
           dispatching = true;
           const receipt = await service.resume({ uris: [uri], ...device }, { signal });
           started = label(track);

package/src/i18n/messages/de.mjs

@@ -132,6 +132,7 @@ export default {
   "choice.retract": ({ title, artist }) => { const name = title ? `„${title}“ von ${artist}` : artist; return `\n\nZurückgenommen: deine frühere Wahl zu ${name}.`; },
   "generate.made": ({ title, length, seed }) => `Auf diesem Mac mit Stable Audio 3 gemacht: „${title}“ (${length}, Seed ${seed}).`,
   "generate.stream": ({ minutes }) => `Der Stream läuft auf diesem Mac weiter, jedes Mal mit einem neuen Stück, bis zu ${minutes} Minuten. Du kannst ihn jederzeit stoppen.`,
+  "onAir.request": "Geh auf Sendung: Mach neue Musik für jetzt und lass sie weiterlaufen",
   "turn.cancelled": "Weitere Schritte abgebrochen.",
   "turn.interrupted": "Die Antwort wurde unterbrochen. Die erfassten Spotify-Ergebnisse stehen unten; keine Aktion wurde wiederholt.",
 };

package/src/i18n/messages/en.mjs

@@ -133,6 +133,8 @@ export default {
   "choice.retract": ({ title, artist }) => { const name = title ? `"${title}" by ${artist}` : artist; return `\n\nUndone: your earlier choice about ${name}.`; },
   "generate.made": ({ title, length, seed }) => `Made on this Mac with Stable Audio 3: "${title}" (${length}, seed ${seed}).`,
   "generate.stream": ({ minutes }) => `The stream keeps going on this Mac, a new track each time, for up to ${minutes} minutes. Stop it any time.`,
+  // What the listener says to go on air, in the language the reply follows (/onair in the terminal).
+  "onAir.request": "Go on air: make new music for right now and keep it going",
   "turn.cancelled": "Cancelled further work.",
   "turn.interrupted": "The response was interrupted. The recorded Spotify outcomes are below; no action was replayed.",
 };

package/src/i18n/messages/es.mjs

@@ -132,6 +132,7 @@ export default {
   "choice.retract": ({ title, artist }) => { const name = title ? `"${title}" de ${artist}` : artist; return `\n\nDeshecho: tu elección anterior sobre ${name}.`; },
   "generate.made": ({ title, length, seed }) => `Hecho en este Mac con Stable Audio 3: «${title}» (${length}, semilla ${seed}).`,
   "generate.stream": ({ minutes }) => `El flujo sigue en este Mac, con una pista nueva cada vez, hasta ${minutes} minutos. Puedes pararlo cuando quieras.`,
+  "onAir.request": "Sal al aire: crea música nueva para este momento y que siga sonando",
   "turn.cancelled": "Cancelé el resto.",
   "turn.interrupted": "La respuesta se interrumpió. Abajo están los resultados registrados en Spotify; no se repitió ninguna acción.",
 };

package/src/i18n/messages/fr.mjs

@@ -132,6 +132,7 @@ export default {
   "choice.retract": ({ title, artist }) => { const name = title ? `« ${title} » de ${artist}` : artist; return `\n\nAnnulé : votre choix précédent sur ${name}.`; },
   "generate.made": ({ title, length, seed }) => `Fait sur ce Mac avec Stable Audio 3 : « ${title} » (${length}, graine ${seed}).`,
   "generate.stream": ({ minutes }) => `Le flux continue sur ce Mac, avec un nouveau morceau à chaque fois, jusqu'à ${minutes} minutes. Vous pouvez l'arrêter à tout moment.`,
+  "onAir.request": "Prends l'antenne : crée de la musique nouvelle pour ce moment et fais-la durer",
   "turn.cancelled": "Suite annulée.",
   "turn.interrupted": "La réponse a été interrompue. Les résultats Spotify enregistrés figurent ci-dessous ; aucune action n'a été relancée.",
 };

package/src/i18n/messages/it.mjs

@@ -132,6 +132,7 @@ export default {
   "choice.retract": ({ title, artist }) => { const name = title ? `"${title}" di ${artist}` : artist; return `\n\nAnnullato: la tua scelta precedente su ${name}.`; },
   "generate.made": ({ title, length, seed }) => `Fatto su questo Mac con Stable Audio 3: «${title}» (${length}, seed ${seed}).`,
   "generate.stream": ({ minutes }) => `Il flusso continua su questo Mac, con un brano nuovo ogni volta, fino a ${minutes} minuti. Puoi fermarlo quando vuoi.`,
+  "onAir.request": "Vai in onda: crea musica nuova per adesso e tienila accesa",
   "turn.cancelled": "Ho annullato il resto.",
   "turn.interrupted": "La risposta si è interrotta. Gli esiti di Spotify registrati sono qui sotto; nessuna azione è stata ripetuta.",
 };

package/src/i18n/messages/ja.mjs

@@ -132,6 +132,7 @@ export default {
   "choice.retract": ({ title, artist }) => { const name = title ? `${artist}の「${title}」` : artist; return `\n\n取り消しました: ${name}についての前の選択。`; },
   "generate.made": ({ title, length, seed }) => `この Mac の Stable Audio 3 で作りました：「${title}」（${length}、シード ${seed}）。`,
   "generate.stream": ({ minutes }) => `この Mac で一曲ずつ新しい曲を作り続けます（最長 ${minutes} 分）。いつでも止められます。`,
+  "onAir.request": "オンエアして。今の気分に合わせて新しい音楽を作って、流し続けて",
   "turn.cancelled": "以降の処理をキャンセルしました。",
   "turn.interrupted": "返事が中断されました。記録された Spotify の操作結果は下のとおりです。操作は繰り返していません。",
 };

package/src/i18n/messages/ko.mjs

@@ -132,6 +132,7 @@ export default {
   "choice.retract": ({ title, artist }) => { const name = title ? `${artist}의 "${title}"` : artist; return `\n\n취소했습니다: ${name}에 대한 이전 선택.`; },
   "generate.made": ({ title, length, seed }) => `이 Mac의 Stable Audio 3로 만들었습니다: "${title}" (${length}, 시드 ${seed}).`,
   "generate.stream": ({ minutes }) => `이 Mac에서 매번 새 곡을 만들며 최대 ${minutes}분 동안 이어집니다. 언제든 멈출 수 있습니다.`,
+  "onAir.request": "방송 시작해 줘. 지금 분위기에 맞춰 새 음악을 만들어서 계속 틀어 줘",
   "turn.cancelled": "남은 작업을 취소했습니다.",
   "turn.interrupted": "답변이 중단되었습니다. 기록된 Spotify 결과는 아래와 같으며, 어떤 작업도 다시 실행하지 않았습니다.",
 };

package/src/i18n/messages/pt.mjs

@@ -132,6 +132,7 @@ export default {
   "choice.retract": ({ title, artist }) => { const name = title ? `"${title}" de ${artist}` : artist; return `\n\nDesfeito: sua escolha anterior sobre ${name}.`; },
   "generate.made": ({ title, length, seed }) => `Feito neste Mac com o Stable Audio 3: "${title}" (${length}, semente ${seed}).`,
   "generate.stream": ({ minutes }) => `O fluxo continua neste Mac, com uma faixa nova a cada vez, por até ${minutes} minutos. Pare quando quiser.`,
+  "onAir.request": "Entre no ar: crie música nova para agora e mantenha tocando",
   "turn.cancelled": "Cancelei o resto.",
   "turn.interrupted": "A resposta foi interrompida. Abaixo estão os resultados registrados no Spotify; nenhuma ação foi repetida.",
 };

package/src/i18n/messages/zh-Hant.mjs

@@ -132,6 +132,7 @@ export default {
   "choice.retract": ({ title, artist }) => { const name = title ? `${artist}的《${title}》` : artist; return `\n\n已撤銷：你之前對${name}的選擇。`; },
   "generate.made": ({ title, length, seed }) => `用這台 Mac 上的 Stable Audio 3 做的：「${title}」（${length}，種子 ${seed}）。`,
   "generate.stream": ({ minutes }) => `音樂流會在這台 Mac 上一首接一首地做下去，最多 ${minutes} 分鐘，隨時可以停。`,
+  "onAir.request": "開播吧：照現在的感覺做新的音樂，一直放下去",
   "turn.cancelled": "已取消後續操作。",
   "turn.interrupted": "回覆中斷了。已記錄的 Spotify 結果如下；沒有重新執行任何操作。",
 };

package/src/i18n/messages/zh.mjs

@@ -132,6 +132,7 @@ export default {
   "choice.retract": ({ title, artist }) => { const name = title ? `${artist}的《${title}》` : artist; return `\n\n已撤销：你之前对${name}的选择。`; },
   "generate.made": ({ title, length, seed }) => `用这台 Mac 上的 Stable Audio 3 做的：「${title}」（${length}，种子 ${seed}）。`,
   "generate.stream": ({ minutes }) => `音乐流会在这台 Mac 上一首接一首地做下去，最多 ${minutes} 分钟，随时可以停。`,
+  "onAir.request": "开播吧：按现在的感觉做新的音乐，一直放下去",
   "turn.cancelled": "已取消后续操作。",
   "turn.interrupted": "回复中断；已确认的 Spotify 操作结果如下。未重新执行任何操作。",
 };