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

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.2</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.2",
   "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";
@@ -452,6 +453,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);
@@ -869,11 +940,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:
@@ -1167,6 +1242,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) {
@@ -1200,6 +1278,7 @@ async function main() {
     unobservePlayer?.();
     unobserveStream?.();
     unwatchStreamGeneration?.();
+    unwatchStreamMusicApp?.();
     atmosphereStream?.stop("closed");
     listeningUpkeep?.stop();
     lyrics?.close();

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();
   }
@@ -829,12 +867,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 +2132,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;
@@ -3289,8 +3326,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: Lass die Musik für jetzt 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: keep the music going for right now",
   "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: que la música siga sonando para este momento",
   "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 : que la musique continue pour ce moment",
   "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: tieni la musica accesa per adesso",
   "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: mantenha a música tocando para agora",
   "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 操作结果如下。未重新执行任何操作。",
 };

package/src/i18n/screen/es.mjs

@@ -1053,4 +1053,11 @@ export default {
   "Play a track Moondog made": "Volver a poner una pista que hizo Moondog",
   "Start a stream": "Empezar un flujo",
   "Stop the stream": "Parar el flujo",
+  "Go on air: Moondog keeps making music from your taste": "Sal al aire: Moondog sigue haciendo música a tu gusto",
+  "on air until {time}": "al aire hasta las {time}",
+  "Cutting the next record": "Grabando el siguiente disco",
+  "Off air: the next record couldn't be made.": "Fuera del aire: no se pudo hacer el siguiente disco.",
+  "The next record is still being cut.": "El siguiente disco aún se está grabando.",
+  "Off air.": "Fuera del aire.",
+  "Turn on music making first: /generation on.": "Primero activa la creación de música: /generation on.",
 };

package/src/i18n/screen/ja.mjs

@@ -1053,4 +1053,11 @@ export default {
   "Play a track Moondog made": "Moondog が作った曲をもう一度かける",
   "Start a stream": "音楽の流れを始める",
   "Stop the stream": "音楽の流れを止める",
+  "Go on air: Moondog keeps making music from your taste": "オンエア：あなたの好みから Moondog が音楽を作り続ける",
+  "on air until {time}": "{time} までオンエア",
+  "Cutting the next record": "次のレコードをカッティング中",
+  "Off air: the next record couldn't be made.": "オフエア：次のレコードを作れませんでした。",
+  "The next record is still being cut.": "次のレコードはまだカッティング中です。",
+  "Off air.": "オフエアにしました。",
+  "Turn on music making first: /generation on.": "先に音楽作りをオンにしてください：/generation on。",
 };

package/src/i18n/screen/pt.mjs

@@ -1053,4 +1053,11 @@ export default {
   "Play a track Moondog made": "Tocar de novo uma faixa que o Moondog fez",
   "Start a stream": "Começar um fluxo",
   "Stop the stream": "Parar o fluxo",
+  "Go on air: Moondog keeps making music from your taste": "Entre no ar: o Moondog segue fazendo música a partir do seu gosto",
+  "on air until {time}": "no ar até {time}",
+  "Cutting the next record": "Gravando o próximo disco",
+  "Off air: the next record couldn't be made.": "Fora do ar: não deu para fazer o próximo disco.",
+  "The next record is still being cut.": "O próximo disco ainda está sendo gravado.",
+  "Off air.": "Fora do ar.",
+  "Turn on music making first: /generation on.": "Ative a criação de música primeiro: /generation on.",
 };

package/src/i18n/screen/zh.mjs

@@ -1053,4 +1053,11 @@ export default {
   "Play a track Moondog made": "再放一首 Moondog 做的曲子",
   "Start a stream": "开始音乐流",
   "Stop the stream": "停止音乐流",
+  "Go on air: Moondog keeps making music from your taste": "开播：Moondog 照着你的口味一直做音乐",
+  "on air until {time}": "播出到 {time}",
+  "Cutting the next record": "正在刻下一张",
+  "Off air: the next record couldn't be made.": "停播了：下一张没刻成。",
+  "The next record is still being cut.": "下一张还在刻。",
+  "Off air.": "已停播。",
+  "Turn on music making first: /generation on.": "先开启音乐生成：/generation on。",
 };

package/src/integrations/apple-music/terminal-preview-player.mjs

@@ -232,6 +232,8 @@ export async function createTerminalPreviewPlayer({
       return true;
     },
     stop,
+    // Leaving Apple Music stops its previews here, never the tracks Moondog made.
+    holdsCatalogSongs: () => Boolean(queue?.tracks.some((track) => !track.generated)),
     subscribe(listener) {
       listeners.add(listener);
       return () => listeners.delete(listener);

package/src/integrations/netease/ncm-cli-player.mjs

@@ -245,9 +245,10 @@ export function createNeteasePlayer({
      * up. mode "play" replaces the queue and starts the first; "queue" adds after what is
      * playing. Songs NetEase marks as not playable are never sent to the player, nor songs
      * allow(song) refuses, such as the listener's Avoids; those are only counted. Before a lookup,
-     * allow gets the title and artist asked for, as { title, artist_credit }.
+     * allow gets the title and artist asked for, as { title, artist_credit }. beforePlay runs just
+     * before a song starts, which a queue with nothing loaded does too.
      */
-    async play({ items = [], mode = "play", intent, allow = () => true } = {}) {
+    async play({ items = [], mode = "play", intent, allow = () => true, beforePlay } = {}) {
       const found = [];
       const unplayable = [];
       const notFound = [];
@@ -278,6 +279,7 @@ export function createNeteasePlayer({
           queue = [...queue, ...songs];
           outcome = "queued";
         } else {
+          await beforePlay?.();
           queue = songs;
           await playAt(0);
           outcome = "playing";
@@ -297,15 +299,19 @@ export function createNeteasePlayer({
       checked(await run(["resume"]), "resume");
       stayConnected();
     },
-    async next() {
+    // beforePlay runs just before a song starts, so the other players go quiet only for one.
+    async next({ beforePlay } = {}) {
       if (index + 1 >= queue.length) throw failure("netease_failed", "Nothing is queued after this song.");
+      await beforePlay?.();
       await playAt(index + 1);
     },
     // Back to the start of the song, or to the one before when it has only just begun.
-    async previous() {
+    async previous({ beforePlay } = {}) {
       const now = await state();
-      if (index > 0 && (Number(now.position) || 0) <= 3) await playAt(index - 1);
-      else checked(await run(["seek", "0"]), "go back to the start");
+      if (index > 0 && (Number(now.position) || 0) <= 3) {
+        await beforePlay?.();
+        await playAt(index - 1);
+      } else checked(await run(["seek", "0"]), "go back to the start");
     },
     async seek({ positionMs = 0 } = {}) {
       checked(await run(["seek", String(Math.max(0, Math.round(positionMs / 1000)))]), "move in the song");

package/src/integrations/stable-audio/local-generator.mjs

@@ -401,9 +401,10 @@ export function createLocalGenerator({
     restart(id) {
       if (playing?.id === id) playing = null;
     },
-    // A play Moondog cut off as it began, as a stream past its time limit does, says nothing about the listener.
+    // A play Moondog cut off as it began, as a stream past its time limit does, says nothing about the
+    // listener. Without an id, whatever made track plays now, as when a stream's first track replaces it.
     discard(id) {
-      if (playing?.id === id) playing = null;
+      if (playing && (id === undefined || playing.id === id)) playing = null;
     },
     recordReplay(id, by) {
       this.restart(id);
@@ -510,12 +511,53 @@ export function createLocalGenerator({
 const STREAM_SKIP_MS = 30_000;
 export function createAtmosphereStream({ generator, player, now = Date.now, keepAudio = 3 }) {
   let stream = null;
+  // What the surfaces see (view()) and hear (subscribe): the phase, and the end with its reason.
+  const listeners = new Set();
+  let shown = "null";
+  // Events wait their turn, so a listener that stops the stream from inside one never reorders them.
+  const events = [];
+  let delivering = false;
+  const deliver = (event) => {
+    events.push(event);
+    if (delivering) return;
+    delivering = true;
+    try {
+      while (events.length) {
+        const next = events.shift();
+        for (const listener of [...listeners]) {
+          try { listener(structuredClone(next)); } catch { /* A surface's redraw cannot stop the stream. */ }
+        }
+      }
+    } finally {
+      delivering = false;
+    }
+  };
+  const viewOf = (current) => current ? {
+    // Nothing of it plays yet; it waits in the dry gap for its next track; it makes the next behind one loaded; or it only plays.
+    phase: !current.current ? "starting" : current.waiting ? "waiting" : current.making ? "making" : "playing",
+    started_at: new Date(current.startedAt).toISOString(), ends_at: new Date(current.endsAt).toISOString(), tracks_made: current.made.length,
+  } : null;
+  // Called after anything that may change the view; only a real change reaches the listeners.
+  const changed = () => {
+    const view = viewOf(stream);
+    const key = JSON.stringify(view);
+    if (key === shown) return;
+    shown = key;
+    deliver({ view, ended: null });
+  };
+  // The tracks of a stream that gave way to Moondog's next one, while the player may still hold one of
+  // them; a listener's stop before the new stream's first track plays stops them too.
+  let heldOver = null;
   const end = (reason) => {
     const ending = stream;
     if (!ending) return null;
     stream = null;
     ending.controller.abort();
     ending.ended = reason;
+    heldOver = reason === "replaced" && (ending.current || heldOver)
+      ? new Set([...(heldOver ?? []), ...ending.made.map((made) => made.id)]) : null;
+    shown = "null";
+    deliver({ view: null, ended: reason });
     return ending;
   };
   const trackFor = (ending, position) => {
@@ -564,6 +606,7 @@ export function createAtmosphereStream({ generator, player, now = Date.now, keep
     const current = stream;
     if (!current || current.making || current.next || !fits(current)) return;
     current.making = true;
+    changed();
     try {
       const { prompt, title, receipt, variation } = trackFor(current, current.made.length);
       const made = await generator.generate({ prompt, seconds: current.seconds, title, receipt }, { signal: current.controller.signal });
@@ -574,6 +617,8 @@ export function createAtmosphereStream({ generator, player, now = Date.now, keep
       if (current.waiting && expired(current)) { end("time"); return; }
       current.made.push({ id: made.id, featured: variation.featured, started: false, seconds: made.duration_seconds });
       current.next = made.id;
+      // Made, so what the player reports from here on sees the stream as only playing.
+      current.making = false;
       const track = { id: made.id, title: made.title, seconds: made.duration_seconds, file };
       // A queue that ran dry while this was made starts again with it.
       if (current.waiting) { current.waiting = false; player.playGenerated(track); } else player.enqueueGenerated(track);
@@ -583,6 +628,52 @@ export function createAtmosphereStream({ generator, player, now = Date.now, keep
       if (stream === current && error?.code !== "generation_stopped") end("failed");
     } finally {
       current.making = false;
+      changed();
+    }
+  };
+  // What the room's player reports moves the stream along or ends it.
+  const move = (event) => {
+    const current = stream;
+    // Until its first track plays, what the player reports is about the music before it.
+    if (!current || !current.current) return;
+    const track = event?.track;
+    const ours = (id) => current.made.some((made) => made.id === id);
+    // A queue or a song that is not one of the stream's tracks is other music, which ends the stream.
+    if (event?.type === "queue" || event?.type === "playing") {
+      const items = Array.isArray(event.tracks) ? event.tracks : track ? [track] : [];
+      if (items.some((item) => !item?.generated || (item.id && !ours(item.id)))) { end("other_music"); return; }
+    }
+    const isCurrent = track?.id && track.id === current.current.id;
+    if (event?.type === "playing" && track?.id && track.id === current.next) {
+      // The window may already have moved on to it when the time limit had passed. The generator
+      // has begun counting it, and Moondog's own stop must not read as the listener's skip.
+      if (expired(current)) { generator.discard?.(track.id); endInTime(); return; }
+      leftEarly(current);
+      const made = current.made.find((entry) => entry.id === track.id);
+      current.current = { id: track.id, heardMs: 0, since: now(), finished: false, seconds: made?.seconds };
+      if (made) made.started = true;
+      current.next = null;
+      current.waiting = false;
+      prune(current);
+      void makeNext();
+    } else if (event?.type === "paused" && isCurrent && current.current.since !== null) {
+      current.current.heardMs += now() - current.current.since;
+      current.current.since = null;
+    } else if (event?.type === "playing" && isCurrent && current.current.since === null) {
+      current.current.since = now();
+    } else if (event?.type === "skipped" && isCurrent) {
+      // A skip past the end of the queue moves on to the next track once it is made.
+      leftEarly(current);
+      current.current.finished = true;
+      if (!current.next) ranDry(current);
+      else if (expired(current)) endInTime();
+    } else if ((event?.type === "finished" || event?.type === "failed") && isCurrent) {
+      // A track that could not play says nothing about the listener; it is passed over like one that ended.
+      current.current.finished = true;
+      if (!current.next) ranDry(current);
+      else if (expired(current)) endInTime();
+    } else if (event?.type === "stopped" && !current.waiting && !current.starting) {
+      end("stopped");
     }
   };
   return {
@@ -593,17 +684,25 @@ export function createAtmosphereStream({ generator, player, now = Date.now, keep
       return { tracks_made: stream.made.length, started_at: new Date(stream.startedAt).toISOString(),
         ends_at: new Date(stream.endsAt).toISOString(), steering_away_from: [...stream.leaveOut] };
     },
+    /** For the surfaces: { phase, started_at, ends_at, tracks_made }, or null when no stream runs. */
+    view: () => viewOf(stream),
+    /** Hears { view, ended } once for each change: the start, each phase, each track made, and the end with its reason. */
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
     /**
      * Starts a stream from a compiled taste and plays its first track; the next is made at once.
      * beforePlay runs once the first track exists, so other music pauses only when there is one to
-     * play. Returns the first track. A stream already running gives way to the new one.
+     * play. Returns the first track. A stream already running gives way to the new one, and its track
+     * plays on until the first new one takes over, so nothing goes silent while that is made.
      */
     async start({ compiled, title, seconds, minutes, receipt = {} }, { signal, onProgress, onTrack, beforePlay } = {}) {
-      const previous = end("replaced");
-      if (previous?.current) player.stop?.();
+      end("replaced");
       const current = { compiled, title, seconds, receipt, onTrack, startedAt: now(), endsAt: now() + minutes * 60_000,
         made: [], leaveOut: new Set(), current: null, next: null, waiting: false, making: true, controller: new AbortController() };
       stream = current;
+      changed();
       const stopped = () => Object.assign(new Error("The stream was stopped before it began."), { code: "generation_stopped" });
       try {
         const { prompt, title: first, receipt: firstReceipt, variation } = trackFor(current, 0);
@@ -617,67 +716,43 @@ export function createAtmosphereStream({ generator, player, now = Date.now, keep
         current.made.push({ id: made.id, featured: variation.featured, started: true, seconds: made.duration_seconds });
         current.current = { id: made.id, heardMs: 0, since: now(), finished: false, seconds: made.duration_seconds };
         current.making = false;
+        // The made track it replaces, a single one or the last stream's, was cut off by Moondog, not
+        // left by the listener: counted as a skip, it would steer later tracks away from its sound.
+        generator.discard?.();
         // Whatever was playing stops for the first track; that stop is not the listener's.
         current.starting = true;
         try { player.playGenerated({ id: made.id, title: made.title, seconds: made.duration_seconds, file }); } finally { current.starting = false; }
+        heldOver = null;
         onTrack?.(made);
         void makeNext();
+        changed();
         return { made, prompt, variation };
       } catch (error) {
-        if (stream === current) end("failed");
+        // A reply stopped while the first track was made is the listener's own stop, not a failure.
+        if (stream === current) end(error?.code === "generation_stopped" ? "asked" : "failed");
+        // Why it ended tells the listener turning it off apart from a stop of the reply.
+        if (error?.code === "generation_stopped" && error.ended === undefined) error.ended = current.ended ?? null;
         throw error;
       }
     },
     stop(reason = "asked") {
+      const held = heldOver;
       const ending = end(reason);
-      // Before its first track plays, the player still holds the music from before the stream, which stays.
-      if (ending?.current) player.stop?.();
+      // Before its first track plays, the player still holds the music from before the stream, which
+      // stays, unless that is the track of the stream it replaced. A stream replaced by Moondog's next
+      // track or stream plays on until that one takes over.
+      if (ending && reason !== "replaced" && (ending.current || held)) player.stop?.();
       return ending ? { tracks_made: ending.made.length } : null;
     },
     /** What the room's player reports, which moves the stream along or ends it. */
     observe(event) {
-      const current = stream;
-      // Until its first track plays, what the player reports is about the music before it.
-      if (!current || !current.current) return;
-      const track = event?.track;
-      const ours = (id) => current.made.some((made) => made.id === id);
-      // A queue or a song that is not one of the stream's tracks is other music, which ends the stream.
-      if (event?.type === "queue" || event?.type === "playing") {
-        const items = Array.isArray(event.tracks) ? event.tracks : track ? [track] : [];
-        if (items.some((item) => !item?.generated || (item.id && !ours(item.id)))) { end("other_music"); return; }
-      }
-      const isCurrent = track?.id && track.id === current.current.id;
-      if (event?.type === "playing" && track?.id && track.id === current.next) {
-        // The window may already have moved on to it when the time limit had passed. The generator
-        // has begun counting it, and Moondog's own stop must not read as the listener's skip.
-        if (expired(current)) { generator.discard?.(track.id); endInTime(); return; }
-        leftEarly(current);
-        const made = current.made.find((entry) => entry.id === track.id);
-        current.current = { id: track.id, heardMs: 0, since: now(), finished: false, seconds: made?.seconds };
-        if (made) made.started = true;
-        current.next = null;
-        current.waiting = false;
-        prune(current);
-        void makeNext();
-      } else if (event?.type === "paused" && isCurrent && current.current.since !== null) {
-        current.current.heardMs += now() - current.current.since;
-        current.current.since = null;
-      } else if (event?.type === "playing" && isCurrent && current.current.since === null) {
-        current.current.since = now();
-      } else if (event?.type === "skipped" && isCurrent) {
-        // A skip past the end of the queue moves on to the next track once it is made.
-        leftEarly(current);
-        current.current.finished = true;
-        if (!current.next) ranDry(current);
-        else if (expired(current)) endInTime();
-      } else if ((event?.type === "finished" || event?.type === "failed") && isCurrent) {
-        // A track that could not play says nothing about the listener; it is passed over like one that ended.
-        current.current.finished = true;
-        if (!current.next) ranDry(current);
-        else if (expired(current)) endInTime();
-      } else if (event?.type === "stopped" && !current.waiting && !current.starting) {
-        end("stopped");
+      // Other music, or a stop, means the player no longer holds the replaced stream's tracks.
+      if (heldOver) {
+        const items = Array.isArray(event?.tracks) ? event.tracks : event?.track ? [event.track] : [];
+        if (event?.type === "stopped" || ((event?.type === "queue" || event?.type === "playing") && items.some((item) => !heldOver.has(item?.id)))) heldOver = null;
       }
+      move(event);
+      changed();
     },
   };
 }

package/src/runtime/pi/agent-runtime.mjs

@@ -5249,7 +5249,7 @@ function createToolFactories(
           name: descriptor.tool_name,
           label: descriptor.label,
           description:
-            "Start Moondog's stream: instrumental tracks made on this Mac from the listener's taste, one after another, for background listening (work, reading, a long evening). The first plays at once; each next one is made while the last plays, and features a different few of the descriptors, so give a broad set: genres, plus several instruments, textures, moods and rhythms. Descriptors, sources and rules are the same as moondog_make_track. A track the listener skips within 30 seconds steers the stream away from what it featured. seconds is each track's length, 60 to 380, 150 when left out; minutes is how long the stream runs, 10 to 180, 60 when left out. Starting one replaces a stream already running, and making a single track ends it. Use it only when the listener asks for music to keep going in the background; for one track, use moondog_make_track. Say in one or two sentences what shapes it, and that they can stop it any time; the host writes its own line under the reply.",
+            "Start Moondog's stream: instrumental tracks made on this Mac from the listener's taste, one after another, for background listening (work, reading, a long evening). The first plays at once; each next one is made while the last plays, and features a different few of the descriptors, so give a broad set: genres, plus several instruments, textures, moods and rhythms. Descriptors, sources and rules are the same as moondog_make_track. A track the listener skips within 30 seconds steers the stream away from what it featured. seconds is each track's length, 60 to 380, 150 when left out; minutes is how long the stream runs, 10 to 180, 60 when left out. Starting one replaces a stream already running, and making a single track ends it. Use it only when the listener asks for music to keep going in the background; for one track, use moondog_make_track. Say in one or two sentences what shapes it, and that they can stop it any time; the host writes its own line under the reply. If state is not_made with reason stopped_by_listener, the listener turned the stream off while its first track was made: that is their choice, not a failure, so do not start it again in this turn; acknowledge it in a few words.",
           parameters: Type.Object(
             {
               descriptors: Type.Array(descriptorSchema, { minItems: 1, maxItems: DESCRIPTOR_LIMITS.total }),

package/src/surfaces/cli/tui.mjs

@@ -1,5 +1,5 @@
 import { homedir } from "node:os";
-import { LOCALES, N_, liveScreenTranslator, normalizeLocale } from "../../i18n/index.mjs";
+import { LOCALES, N_, intlLocale, liveScreenTranslator, normalizeLocale, translator } from "../../i18n/index.mjs";
 import {
   CombinedAutocompleteProvider,
   Container,
@@ -126,6 +126,7 @@ const slashCommands = [
   { name: "web", description: N_("Look things up on public music sites") },
   { name: "service", description: N_("Choose where Moondog plays music") },
   { name: "generation", description: N_("Let Moondog make music on this Mac") },
+  { name: "onair", description: N_("Go on air: Moondog keeps making music from your taste") },
   { name: "spotify", description: N_("Connect and control Spotify") },
   { name: "skip", description: N_("Skip to the next song preview") },
   { name: "stop", description: N_("Stop the song previews") },
@@ -246,8 +247,10 @@ export async function runMoondogTui({
   // /skip and /stop exist only where the room controls the previews itself.
   const previewControls = typeof previewPlayer?.subscribe === "function" &&
     typeof previewPlayer.skip === "function" && typeof previewPlayer.stop === "function";
+  // /onair needs both: the room's own player and music making here.
+  const onAirControls = previewControls && typeof generation?.save === "function";
   const commands = slashCommands.filter(({ name }) => (previewControls || !["skip", "stop"].includes(name)) &&
-    (name !== "generation" || typeof generation?.save === "function"));
+    (name !== "generation" || typeof generation?.save === "function") && (name !== "onair" || onAirControls));
   const localizedCommands = commands.map(({ name, description }) => ({ name, get description() { return tr.marked(description); } }));
   let activeRuntime = runtime;
   application.startNewSession?.("tui_start");
@@ -326,7 +329,20 @@ export async function runMoondogTui({
     : Math.min(messageQueue.length, 4) + (messageQueue.length > 4 ? 1 : 0);
   // The preview now playing sits on its own line above the draft.
   let nowPlaying = null;
-  const nowPlayingRows = () => (nowPlaying && !profileView && !importView && !firstRunView ? 1 : 0);
+  // Moondog's stream as the core shows it: null, or { phase, started_at, ends_at, tracks_made }.
+  let onAir = application.streamView?.() ?? null;
+  // Between two of the stream's tracks nothing plays, and the line says the next one is being made.
+  const dryGap = () => !nowPlaying && onAir?.phase === "waiting";
+  const nowPlayingRows = () => ((nowPlaying || dryGap()) && !profileView && !importView && !firstRunView ? 1 : 0);
+  // When the stream ends at the latest, as a clock time: an upper bound, so never a countdown. The clock
+  // follows the screen's language, as the words around it do.
+  const onAirUntil = () => {
+    const ends = new Date(onAir?.ends_at);
+    let time;
+    try { time = new Intl.DateTimeFormat(intlLocale(tr.locale), { hour: "numeric", minute: "2-digit" }).format(ends); }
+    catch { time = ends.toTimeString().slice(0, 5); }
+    return tr("on air until {time}", { time });
+  };
   let cancelWork = null;
   let cancellationRequested = false;
   let workStartedAt = 0;
@@ -481,16 +497,21 @@ export async function runMoondogTui({
     render(width) {
       if (profileView || importView || firstRunView) return [];
       const lines = [];
-      if (nowPlaying) {
-        const { track, position, count, type } = nowPlaying;
+      if (nowPlaying || dryGap()) {
+        const { track, position, count, type } = nowPlaying ?? {};
         const prefix = `  ${theme.plain ? ">" : "♪"} `;
         // Where the terminal can't open links, the note in the conversation shows the address.
-        const apple = getCapabilities().hyperlinks ? hyperlink("Apple Music", track.catalog_url) : "Apple Music";
+        const apple = nowPlaying && getCapabilities().hyperlinks ? hyperlink("Apple Music", track.catalog_url) : "Apple Music";
         const state = type === "loading" ? tr("loading") : type === "paused" ? tr("paused") : "";
+        // Once its first track plays, a made track is the stream's, which goes on to the next with /skip.
+        const onAirTrack = track?.generated && onAir && onAir.phase !== "starting";
         // A track Moondog made is its own record, kept on this Mac, with nothing to open elsewhere.
-        const controls = track.generated ? `${state ? `  ${state}` : ""}  · /stop`
+        const controls = !nowPlaying ? `  · ${onAirUntil()} · /stop`
+          : onAirTrack ? `${state ? `  ${state}` : ""}  · ${onAirUntil()} · /skip · /stop`
+          : track.generated ? `${state ? `  ${state}` : ""}  · /stop`
           : `  ${position}/${count}${state ? ` · ${state}` : ""} · ${apple} · /skip · /stop`;
-        const song = sanitizeTerminalText(`${track.title} · ${track.generated ? tr("Made by Moondog") : track.artist_credit}`).replace(/\s+/gu, " ").trim();
+        const song = !nowPlaying ? tr("Cutting the next record")
+          : sanitizeTerminalText(`${track.title} · ${track.generated ? tr("Made by Moondog") : track.artist_credit}`).replace(/\s+/gu, " ").trim();
         const room = width - visibleWidth(prefix) - visibleWidth(controls);
         lines.push(paintBrandLine(room >= 12
           ? theme.accent(prefix) + theme.text(truncateToWidth(song, room, "…")) + theme.faint(controls)
@@ -722,14 +743,43 @@ export async function runMoondogTui({
     else if (event?.type === "stopped") nowPlaying = null;
     tui.requestRender();
   }) : null;
+  // The stream redraws the line above the draft as it moves on. Ending by itself, it goes dark
+  // without a word; only a track that couldn't be made says so.
+  const stopWatchingStream = application.subscribeStream?.(({ view, ended } = {}) => {
+    if (cleanedUp) return;
+    onAir = view ?? null;
+    if (ended === "failed") setFooter(tr("Off air: the next record couldn't be made."), failure);
+    tui.requestRender();
+  }) ?? null;
   // These act at once, even while Moondog is answering.
   const controlPreviews = (command) => {
     // /stop also ends Moondog's stream while its next track is still being made and nothing plays.
     const streamStopped = command === "stop" && application.stopStream?.()?.state === "stopped";
     const acted = command === "stop" ? previewPlayer.stop() || streamStopped : previewPlayer.skip();
-    if (!busy) setFooter(!acted ? tr("No previews are playing.") : command === "stop" ? tr("Previews stopped.") : tr("Skipped."));
+    const waiting = !acted && command === "skip" && application.streamView?.()?.phase === "waiting";
+    // Off air shows even during a reply: a stream stopped while its first track is made has no row to lose.
+    if (!busy || streamStopped) {
+      setFooter(waiting ? tr("The next record is still being cut.") : !acted ? tr("No previews are playing.")
+        : streamStopped ? tr("Off air.") : command === "stop" ? tr("Previews stopped.") : tr("Skipped."));
+    }
     tui.requestRender();
   };
+  // /onair goes off air at once while a stream runs, even while Moondog is answering, and says so
+  // when music making is off. Otherwise it returns the request to send, in the reply's language.
+  const onAirRequest = () => {
+    if (application.streamView?.()) {
+      application.stopStream();
+      // Said even during a reply: a stream stopped while its first track is made has no line to clear.
+      setFooter(tr("Off air."));
+      return null;
+    }
+    // Music making can be turned off, here or in the window, after the room opened.
+    if (!application.streamReady?.()) {
+      setFooter(tr("Turn on music making first: /generation on."), warning);
+      return null;
+    }
+    return translator(application.locale)("onAir.request");
+  };
 
   // Making music on this Mac. /generation says where it stands; /generation on [folder] turns it on,
   // with the folder of Stability AI's MLX build when it is not the usual one; /generation off turns it off.
@@ -780,6 +830,7 @@ export async function runMoondogTui({
     stopWatchingModel?.();
     stopWatchingFirstRun?.();
     stopWatchingPreviews?.();
+    stopWatchingStream?.();
     clearInterval(indicator);
     indicator = null;
     clearInterval(homeMotion);
@@ -2358,6 +2409,12 @@ export async function runMoondogTui({
         await openCommandPalette();
         return;
       }
+      // Going on air is a request like any other, which the agent answers by starting the stream.
+      if (command === "onair") {
+        const request = onAirRequest();
+        if (request) await submitListeningTurn(request);
+        return;
+      }
       try {
         if (!["home", "theme", "art", "motion", "model", "service", "resume", "rewind", "branch", "new", "taste", "profile", "import"].includes(command)) enterConversation();
         if (command !== "auth") editor.addToHistory(value);
@@ -2545,9 +2602,11 @@ export async function runMoondogTui({
         controlPreviews(pending.slice(1));
         return;
       }
-      if (pending) {
-        if (messageQueue.length >= 30) editor.setText(pending);
-        else messageQueue.push(pending);
+      // /onair stops a stream at once; the request to go on air waits in the queue like any message.
+      const queued = onAirControls && pending === "/onair" ? onAirRequest() : pending;
+      if (queued) {
+        if (messageQueue.length >= 30) editor.setText(queued);
+        else messageQueue.push(queued);
         if (rewindPending) queuePaused = true;
       }
       if (!cleanedUp) tui.requestRender();