@audiofool/moondog 0.2.2 → 0.3.0-beta.10

package/src/surfaces/cli/tui.mjs

@@ -1,4 +1,5 @@
-import { LOCALES, N_, liveScreenTranslator, normalizeLocale } from "../../i18n/index.mjs";
+import { homedir } from "node:os";
+import { LOCALES, N_, intlLocale, liveScreenTranslator, normalizeLocale, translator } from "../../i18n/index.mjs";
 import {
   CombinedAutocompleteProvider,
   Container,
@@ -53,6 +54,10 @@ import {
   setBrandText,
 } from "./brand-components.mjs";
 
+// What making a track says in the footer, stage by stage (src/integrations/stable-audio).
+const generationStages = { starting: N_("warming up"), reading: N_("reading your taste"), composing: N_("composing"),
+  decoding: N_("pressing the record"), writing: N_("saving it") };
+
 // The lines Moondog shows, as a radio host, while the model thinks; the window has the same ones.
 export const hostLines = (tr) => [tr("Reading the room"), tr("Checking the request line"), tr("Finding the groove"), tr("Working the decks"),
   tr("Planning the segue"), tr("Mic check"), tr("Riding the faders"), tr("Finding the cue")];
@@ -120,6 +125,9 @@ const slashCommands = [
   { name: "endpoint", description: N_("Add a model service by its address") },
   { name: "web", description: N_("Look things up on public music sites") },
   { name: "service", description: N_("Choose where Moondog plays music") },
+  { name: "library", description: N_("Your saved songs and playlists") },
+  { 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") },
@@ -223,6 +231,8 @@ export async function runMoondogTui({
   // The terminal's preview player. The room shows what it plays (subscribe) and
   // gives the listener /skip and /stop.
   previewPlayer,
+  // Making music on this Mac with Stable Audio 3: { status, check, save }, or nothing where the room can't play it.
+  generation,
   environment = process.env,
 }) {
   if (providers === listPiProviders && models === listPiModels) {
@@ -238,7 +248,11 @@ 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";
-  const commands = slashCommands.filter(({ name }) => previewControls || !["skip", "stop"].includes(name));
+  // /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 !== "onair" || onAirControls) &&
+    (name !== "library" || application.libraryReady?.() === true));
   const localizedCommands = commands.map(({ name, description }) => ({ name, get description() { return tr.marked(description); } }));
   let activeRuntime = runtime;
   application.startNewSession?.("tui_start");
@@ -282,6 +296,8 @@ export async function runMoondogTui({
   let firstRunNote = null;
   let firstRunSetup = null;
   let firstRunTicket = 0;
+  // The skip being saved, which the room waits for before it closes.
+  let firstRunSaving = null;
   let stopWatchingFirstRun = null;
   let importPage = "start";
   let importReturnHome = false;
@@ -303,6 +319,7 @@ export async function runMoondogTui({
   let busy = false;
   // A model chosen or a sign-in made in the window while a turn ran here; it applies once the turn ends.
   let modelChangedElsewhere = false;
+  let modelAskedFor = null;
   // A reply another Moondog window or terminal is writing in this conversation: { id, response, text }.
   let elsewhere = null;
   let watchTimer = null;
@@ -315,7 +332,24 @@ 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);
+  // Stable Audio 3's setup as the core shows it, here or from the window; a running download has its own line too.
+  let setupStatus = null;
+  const downloading = () => setupStatus?.job && !setupStatus.job.error ? setupStatus.job : null;
+  const downloadRows = () => (downloading() && !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;
@@ -364,7 +398,7 @@ export async function runMoondogTui({
   };
   const sleeve = new RecordSleeve({ terminal, getTheme, environment, getState: () => ({
     focused: homeFocused, selected: homeSelected, motionEnabled,
-    editorRows: (editor.rowCount || 3) + queuedLineCount() + nowPlayingRows(),
+    editorRows: (editor.rowCount || 3) + queuedLineCount() + nowPlayingRows() + downloadRows(),
   }), getNextLyric: () => {
     try {
       homeLyric = homeLyricSeeds ? lyrics.selectHome(homeLyricSeeds) : null;
@@ -430,7 +464,7 @@ export async function runMoondogTui({
     render(width) {
       const lines = conversation.render(width);
       const footerRows = terminal.rows >= 20 ? 2 : 1;
-      const bodyRows = Math.max(1, terminal.rows - 2 - footerRows - queuedLineCount() - nowPlayingRows() - (editor.rowCount || 3));
+      const bodyRows = Math.max(1, terminal.rows - 2 - footerRows - queuedLineCount() - nowPlayingRows() - downloadRows() - (editor.rowCount || 3));
       while (lines.length < bodyRows) lines.push(paintBrandLine("", width, theme));
       return lines;
     },
@@ -470,19 +504,27 @@ 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") : "";
-        const controls = `  ${position}/${count}${state ? ` · ${state}` : ""} · ${apple} · /skip · /stop`;
-        const song = sanitizeTerminalText(`${track.title} · ${track.artist_credit}`).replace(/\s+/gu, " ").trim();
+        // 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 = !nowPlaying ? `  · ${onAirUntil()} · /stop`
+          : onAirTrack ? `${state ? `  ${state}` : ""}  · ${onAirUntil()} · /skip · /stop`
+          : track.generated ? `${state ? `  ${state}` : ""}  · /stop`
+          : `  ${position}/${count}${state ? ` · ${state}` : ""} · ${apple} · /skip · /stop`;
+        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)
           : theme.accent(prefix) + theme.text(truncateToWidth(song, Math.max(1, width - visibleWidth(prefix)), "…")), width, theme));
       }
+      if (downloadRows()) lines.push(paintBrandLine(downloadLine(width), width, theme));
       if (messageQueue.length) {
         const hidden = Math.max(0, messageQueue.length - 4);
         const shown = messageQueue.slice(-4);
@@ -583,6 +625,7 @@ export async function runMoondogTui({
     new CombinedAutocompleteProvider(withCommandCompletions(localizedCommands, {
       // Service keys, such as Brave Search, have no models, so only /auth offers them.
       providers: () => [...providers(), ...serviceKeyProviders], models, authProviderIds: supportedAuthProviderIds, tr,
+      generationSetup: typeof generation?.setup?.install === "function",
     }), process.cwd(), null),
   );
   tui.setFocus(editor);
@@ -602,6 +645,7 @@ export async function runMoondogTui({
     }
     if (!cleanedUp) tui.requestRender();
     if (!value && modelChangedElsewhere) void followModel();
+    if (!value && modelAskedFor) void applyModelAskedFor();
   };
   const setFooter = (text, color = dim) => {
     if (cleanedUp) return;
@@ -702,17 +746,369 @@ export async function runMoondogTui({
   };
   const stopWatchingPreviews = previewControls ? previewPlayer.subscribe((event) => {
     if (cleanedUp) return;
-    if (event?.type === "queue") addPreviewNote(event);
+    // A track Moondog made needs no preview note: the reply names it, and the host's line says where it was made.
+    if (event?.type === "queue") { if (!event.tracks?.some((track) => track.generated)) addPreviewNote(event); }
     else if (event?.type === "failed") markPreviewFailed(event);
     else if (["loading", "playing", "paused"].includes(event?.type)) nowPlaying = event;
     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) => {
-    const acted = command === "stop" ? previewPlayer.stop() : previewPlayer.skip();
-    if (!busy) setFooter(!acted ? tr("No previews are playing.") : command === "stop" ? tr("Previews stopped.") : tr("Skipped."));
+    // /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();
+    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.
+  // Where the core can set Stable Audio 3 up itself (generation.setup), /generation download, use, remove
+  // and cancel manage the models Moondog keeps in its own folder. The window runs the same job, so a
+  // download started there shows here too.
+  const home = homedir();
+  const shownFolder = (folder) => sanitizeTerminalText(String(folder ?? "")).replace(home, "~");
+  const setup = typeof generation?.setup?.install === "function" ? generation.setup : null;
+  // The two models offered, by the word the listener types; sizes are the weights in all, before the
+  // setup reports its own.
+  const sa3Models = {
+    medium: { name: "Medium", choice: "medium", detail: N_("best sound"), total: 5_179_055_990 },
+    "small-music": { name: "Small Music", choice: "small", detail: N_("faster, lighter"), total: 1_704_727_702 },
+  };
+  const modelArgument = (value) => value === "medium" ? "medium" : ["small", "small-music"].includes(value) ? "small-music" : null;
+  const modelName = (model) => sa3Models[model]?.name ?? "Medium";
+  const gigabytes = (bytes) => {
+    const value = Math.max(0, Number(bytes) || 0) / 1e9;
+    try { return new Intl.NumberFormat(intlLocale(tr.locale), { minimumFractionDigits: 1, maximumFractionDigits: 1 }).format(value); }
+    catch { return value.toFixed(1); }
+  };
+  const modelSize = (model, status = setupStatus) => gigabytes(status?.models?.[model]?.total || sa3Models[model]?.total);
+  const setupSteps = { uv: N_("getting uv"), code: N_("getting Stable Audio 3's code"), python: N_("setting up Python"),
+    weights: N_("downloading the model"), verifying: N_("checking the files") };
+  const jobPercent = (job) => job?.total > 0 ? Math.min(100, Math.floor(((job.received ?? 0) / job.total) * 100)) : null;
+  const downloadLine = (width) => {
+    const job = downloading();
+    const prefix = `  ${theme.plain ? "v" : "↓"} `;
+    const percent = jobPercent(job);
+    const step = setupSteps[job.step] ? tr.marked(setupSteps[job.step]) : tr("getting ready");
+    const text = `Stable Audio 3 ${modelName(job.model)} · ${step}${percent === null ? "" : ` ${percent}%`}`;
+    const controls = "  · /generation cancel";
+    const room = width - visibleWidth(prefix) - visibleWidth(controls);
+    return room >= 12 ? theme.accent(prefix) + theme.text(truncateToWidth(text, room, "…")) + theme.faint(controls)
+      : theme.accent(prefix) + theme.text(truncateToWidth(text, Math.max(1, width - visibleWidth(prefix)), "…"));
+  };
+  // One short sentence for a download that stopped on an error, by the setup's code, with the way to try again.
+  const setupErrorText = (error) => {
+    const code = typeof error === "string" ? error : error?.code;
+    if (code === "setup_disk_full") return tr("There isn't enough free space on this Mac for the download. Free some up, then use /generation download again.");
+    if (code === "setup_verification_failed") return tr("A downloaded file didn't match the one Stability AI publishes, so Moondog deleted it. Use /generation download to try again.");
+    if (code === "setup_offline" || code === "setup_download_failed") return tr("The download couldn't reach its source. Check your connection, then use /generation download to try again.");
+    if (code === "setup_python_failed") return tr("Stable Audio 3's Python environment couldn't be set up. Check your connection, then use /generation download to try again.");
+    if (code === "setup_busy") return tr("Another Moondog window or terminal is already downloading. /generation shows how far it is.");
+    const detail = sanitizeTerminalText(String(typeof error === "string" ? error : error?.message ?? code ?? "")).trim();
+    return tr("The download didn't finish: {error}. Use /generation download to try again.", { error: detail || tr("unknown error") });
+  };
+  // The model this room asked for. The core's setup chooses what makes music once it finishes; the
+  // terminal reads that choice and says how to switch when it kept another one.
+  let setupStarted = null;
+  const setupFinished = async (model) => {
+    setupStarted = null;
+    const status = await generation.check().catch(() => null);
+    if (cleanedUp) return;
+    const choice = sa3Models[model]?.choice ?? "medium";
+    setFooter(status?.state === "ready" && status.managed && status.model === model
+      ? tr("Stable Audio 3 {model} is ready. Ask for a track.", { model: modelName(model) })
+      : tr("Stable Audio 3 {model} is downloaded. Use it with /generation use {choice}.", { model: modelName(model), choice }), success);
+  };
+  const stopWatchingSetup = setup?.subscribe?.((status) => {
+    if (cleanedUp) return;
+    // The first snapshot is where things stand, not a change: an old failure waits for /generation.
+    const first = setupStatus === null;
+    const before = setupStatus?.job ?? null;
+    setupStatus = status ?? null;
+    const job = setupStatus?.job ?? null;
+    if (first) { tui.requestRender(); return; }
+    if (job?.error && !before?.error) setFooter(setupErrorText(job.error), failure);
+    else if (before && !before.error && !job) {
+      if (setupStatus?.models?.[before.model]?.state === "ready") void setupFinished(before.model);
+      else {
+        if (setupStarted === before.model) setupStarted = null;
+        setFooter(tr("Download stopped. /generation download {choice} picks it up where it left off.", { choice: sa3Models[before.model]?.choice ?? "medium" }));
+      }
+    }
     tui.requestRender();
+  }) ?? null;
+  if (setup) {
+    Promise.resolve().then(() => setup.status()).then((status) => {
+      if (cleanedUp || setupStatus) return;
+      setupStatus = status ?? null;
+      tui.requestRender();
+    }, () => {});
+  }
+  // A fresh read for a command. The line above the draft follows subscribe alone, so a job that ends
+  // while a command reads still counts as finished.
+  const readSetup = async () => await setup.status();
+  // What each model is: its size, whether it's here, in use, or on its way.
+  const setupSummary = (status, generationStatus) => {
+    const lines = Object.entries(sa3Models).map(([model, { name, detail }]) => {
+      const entry = status?.models?.[model] ?? { state: "absent" };
+      const job = status?.job?.model === model ? status.job : null;
+      const percent = jobPercent(job);
+      const state = job?.error ? tr("download stopped on an error")
+        : job ? percent === null ? tr("downloading") : tr("downloading, {percent}%", { percent })
+        : entry.state === "ready"
+          ? generationStatus?.managed && generationStatus.model === model ? tr("installed, in use") : tr("installed")
+          : entry.state === "partial" ? tr("partly downloaded") : tr("not downloaded");
+      return `- Stable Audio 3 ${name} · ${tr.marked(detail)} · ${tr("{size} GB", { size: modelSize(model, status) })} · ${state}`;
+    });
+    const notes = [];
+    if (status?.job?.error) notes.push(setupErrorText(status.job.error));
+    if (generationStatus && !generationStatus.managed && generationStatus.install === "ready") {
+      notes.push(tr("In use: your own install at {folder}.", { folder: shownFolder(generationStatus.path) }));
+    }
+    notes.push(tr("Get a model with /generation download medium or small. /generation use, remove and cancel manage them."));
+    return [lines.join("\n"), ...notes].join("\n\n");
+  };
+  const generationMessage = (status) => {
+    const folder = shownFolder(status?.path);
+    if (status?.install === "unsupported") return tr("Stable Audio 3 needs a Mac with Apple silicon, so Moondog can't make music here.");
+    if (status?.state === "ready") return tr("Moondog makes music on this Mac with Stable Audio 3, powered by Stability AI. Ask for a track. Stable Audio 3 runs offline, and the track stays on this Mac.");
+    // Moondog's own install, or nothing anywhere yet: a download sets it up.
+    if (setup && status?.install !== "ready" && (status?.managed || (status?.source === "default" && status?.install === "missing"))) {
+      if (status?.state === "off") return tr("Making music on this Mac is off. Get Stable Audio 3 with /generation download medium, or small for a lighter model; music making turns on when it's done.");
+      const model = status?.model in sa3Models ? status.model : "medium";
+      return tr("Stable Audio 3 {model} isn't downloaded yet. Get it with /generation download {choice}.", { model: modelName(model), choice: sa3Models[model].choice });
+    }
+    if (status?.state === "off") {
+      if (status.install === "ready" && status.managed) return tr("Making music on this Mac is off. Stable Audio 3 {model} is ready; turn it on with /generation on.", { model: modelName(status.model) });
+      if (status.install === "ready") return tr("Making music on this Mac is off. Stable Audio 3 is ready at {folder}; turn it on with /generation on.", { folder });
+      if (status.install === "incomplete") return tr("Making music on this Mac is off, and Stable Audio 3 at {folder} isn't fully installed. Run ./install.sh --download medium there, then use /generation on.", { folder });
+      return tr("Making music on this Mac is off, and Stable Audio 3 isn't at {folder}. Install Stability AI's MLX build from github.com/Stability-AI/stable-audio-3, then use /generation on with its folder.", { folder });
+    }
+    if (status?.state === "incomplete") {
+      return status.missing === "weights"
+        ? tr("Stable Audio 3 at {folder} doesn't have the Medium model yet. Run ./install.sh --download medium there, then use /generation again.", { folder })
+        : tr("Stable Audio 3 at {folder} isn't installed yet. Run ./install.sh --download medium there, then use /generation again.", { folder });
+    }
+    return tr("Stable Audio 3 isn't at {folder}. Use /generation on with the folder that holds its sa3 script.", { folder });
+  };
+  const generationFooter = (status) => setFooter(status.state === "ready" ? tr("Music making on.") : status.state === "off" ? tr("Music making off.") : tr("Music making isn't ready."),
+    status.state === "ready" || status.state === "off" ? dim : warning);
+  const setupUsage = () => tr("Use /generation download, use or remove with medium or small, or /generation cancel.");
+  // /generation download, use, remove and cancel. A first download asks for the licenses with --agree;
+  // a removal asks once with --yes. The download runs in the background, on its own line above the draft.
+  const manageSetup = async (action, rest) => {
+    const flags = rest.filter((value) => value.startsWith("--"));
+    const values = rest.filter((value) => !value.startsWith("--"));
+    const allowed = action === "download" ? ["--agree"] : action === "remove" ? ["--yes"] : [];
+    const model = modelArgument(values[0]);
+    if ((action === "cancel" ? values.length > 0 : values.length !== 1 || !model) || flags.some((flag) => !allowed.includes(flag))) {
+      throw new Error(setupUsage());
+    }
+    const status = await readSetup();
+    if (status?.supported === false) {
+      addMoondogMessage(tr("Stable Audio 3 needs a Mac with Apple silicon, so Moondog can't make music here."));
+      setFooter(tr("Music making isn't ready."), warning);
+      return;
+    }
+    const running = status?.job && !status.job.error ? status.job : null;
+    if (action === "cancel") {
+      if (!running) { setFooter(tr("No download is running.")); return; }
+      await setup.cancel();
+      setFooter(tr("Download stopped. /generation download {choice} picks it up where it left off.", { choice: sa3Models[running.model]?.choice ?? "medium" }));
+      return;
+    }
+    const name = modelName(model);
+    const { choice } = sa3Models[model];
+    const entry = status?.models?.[model] ?? { state: "absent" };
+    if (action === "download") {
+      if (running) {
+        setFooter(running.model === model ? tr("Stable Audio 3 {model} is already downloading.", { model: name })
+          : tr("Another download is running. /generation cancel stops it."), running.model === model ? dim : warning);
+        return;
+      }
+      if (entry.state === "ready") {
+        addMoondogMessage(tr("Stable Audio 3 {model} is already on this Mac. Use it with /generation use {choice}.", { model: name, choice }));
+        setFooter(tr("Already downloaded."));
+        return;
+      }
+      const accepted = flags.includes("--agree");
+      if (!status?.licenses?.accepted && !accepted) {
+        addMoondogMessage(tr("Stable Audio 3 comes under the Stability AI Community License ({license}), and its text encoder, T5Gemma, under the Gemma Terms of Use ({gemma}). Moondog downloads it only from Stability AI's official sources and checks every file.\n\nTo agree and download {model} ({size} GB): /generation download {choice} --agree", {
+          license: status?.licenses?.links?.find(({ id }) => id === "stability-ai-community")?.url ?? "https://stability.ai/license",
+          gemma: status?.licenses?.links?.find(({ id }) => id === "gemma-terms")?.url ?? "https://huggingface.co/stabilityai/stable-audio-3-optimized/blob/main/LICENSE_GEMMA.md",
+          model: name, size: modelSize(model, status), choice,
+        }));
+        setFooter(tr("Waiting for your agreement."));
+        return;
+      }
+      setupStarted = model;
+      Promise.resolve().then(() => setup.install(model, { accepted })).catch((error) => {
+        if (setupStarted === model) setupStarted = null;
+        // A cancel ends the job too; the setup's own snapshot says so.
+        if (cleanedUp || error?.code === "setup_cancelled") return;
+        addMoondogMessage(setupErrorText(error));
+        setFooter(tr("The download didn't finish."), failure);
+      });
+      addMoondogMessage(tr("Downloading Stable Audio 3 {model} ({size} GB) from Stability AI's official sources. It runs in the background; /generation cancel stops it, and a later download picks up where it left off.", {
+        model: name, size: modelSize(model, status),
+      }));
+      setFooter(tr("Downloading Stable Audio 3 {model}.", { model: name }));
+      return;
+    }
+    if (action === "use") {
+      if (entry.state !== "ready") {
+        addMoondogMessage(tr("Stable Audio 3 {model} isn't downloaded yet. Get it with /generation download {choice}.", { model: name, choice }));
+        setFooter(tr("Music making isn't ready."), warning);
+        return;
+      }
+      const result = await generation.save({ enabled: true, source: "managed", model });
+      addMoondogMessage(generationMessage(result));
+      generationFooter(result);
+      return;
+    }
+    // remove
+    if (running) {
+      addMoondogMessage(tr("Wait for the download to finish, or stop it with /generation cancel, before removing a model."));
+      setFooter(tr("A download is running."), warning);
+      return;
+    }
+    if (entry.state === "absent") {
+      setFooter(tr("Stable Audio 3 {model} isn't on this Mac.", { model: name }));
+      return;
+    }
+    if (!flags.includes("--yes")) {
+      const last = Object.keys(sa3Models).every((other) => other === model || (status?.models?.[other]?.state ?? "absent") === "absent");
+      const size = gigabytes(entry.bytes || entry.total || sa3Models[model].total);
+      addMoondogMessage(last
+        ? tr("Removing Stable Audio 3 {model} deletes its {size} GB from this Mac. It's the last model, so the rest of Moondog's Stable Audio 3 setup goes too. To go ahead: /generation remove {choice} --yes", { model: name, size, choice })
+        : tr("Removing Stable Audio 3 {model} deletes its {size} GB from this Mac. To go ahead: /generation remove {choice} --yes", { model: name, size, choice }));
+      setFooter(tr("Nothing removed yet."));
+      return;
+    }
+    await setup.remove(model);
+    await readSetup().catch(() => null);
+    const after = await generation.check().catch(() => null);
+    addMoondogMessage(tr("Removed Stable Audio 3 {model} from this Mac.", { model: name }));
+    setFooter(after?.state === "ready" ? tr("Removed.") : tr("Removed. Music making isn't ready."), after?.state === "ready" ? success : warning);
+  };
+  const manageGeneration = async (args) => {
+    const [action, ...rest] = args;
+    if (setup && ["download", "use", "remove", "cancel"].includes(action)) {
+      await manageSetup(action, rest);
+      return;
+    }
+    if ((action && !["on", "off"].includes(action)) || (action === "off" && rest.length)) {
+      throw new Error(setup ? tr("Use /generation, /generation on [folder] or off, or /generation download, use or remove with medium or small.")
+        : tr("Use /generation, /generation on [folder], or /generation off."));
+    }
+    const status = action ? await generation.save({ enabled: action === "on", ...(rest.length ? { path: rest.join(" ") } : {}) })
+      : await generation.check();
+    const summary = setup && !action && status?.install !== "unsupported" ? await readSetup().then((current) => setupSummary(current, status), () => null) : null;
+    addMoondogMessage(summary ? `${generationMessage(status)}\n\n${summary}` : generationMessage(status));
+    generationFooter(status);
+  };
+
+  // /library lists Saved and the listener's folders and playlists, plays one by name, or keeps the song
+  // playing now, in Saved or in a playlist by name (made when there is none). The window shares this library.
+  const manageLibrary = async (args) => {
+    if (!application.libraryReady?.()) throw new Error(tr("The library isn't available here."));
+    const [action, ...rest] = args;
+    const words = rest.join(" ").trim();
+    const nameOf = (playlist) => (playlist.saved ? tr("Saved") : playlist.name);
+    if (!action) {
+      const { folders, playlists } = application.libraryView();
+      const count = (playlist) => tr.n(playlist.count, "{count} song", "{count} songs");
+      const lines = [];
+      const saved = playlists.find((playlist) => playlist.saved);
+      if (saved) lines.push(`- **${nameOf(saved)}** · ${count(saved)}`);
+      const walk = (parentId, depth) => {
+        const nodes = [...folders.filter((folder) => folder.parentId === parentId).map((node) => ["folder", node]),
+          ...playlists.filter((playlist) => !playlist.saved && playlist.folderId === parentId).map((node) => ["playlist", node])]
+          .sort((a, b) => a[1].position - b[1].position);
+        for (const [kind, node] of nodes) {
+          const indent = "  ".repeat(depth);
+          if (kind === "folder") { lines.push(`${indent}- ${node.name}/`); walk(node.id, depth + 1); }
+          else lines.push(`${indent}- **${node.name}** · ${count(node)}`);
+        }
+      };
+      walk(null, 0);
+      addMoondogMessage(`${lines.join("\n")}\n\n${tr("Play one with `/library play <name>`, or keep the song playing now with `/library save`.")}`);
+      return;
+    }
+    if (action === "play") {
+      const [playlist] = application.findLibraryPlaylists(words);
+      if (!playlist || !words) throw new Error(tr("No playlist is called “{name}”.", { name: words }));
+      const played = await application.playLibrary({ playlistId: playlist.id });
+      if (played.state !== "playing") {
+        addMoondogMessage(played.state === "empty" ? tr("{name} has nothing in it yet.", { name: nameOf(playlist) }) : tr("None of its songs could be found."));
+        return;
+      }
+      addMoondogMessage([tr("Playing {name}.", { name: nameOf(playlist) }),
+        played.left_out_made ? tr("Moondog's tracks were left out. They play with Apple Music chosen.") : "",
+        played.not_found ? tr("Some songs couldn't be found.") : ""].filter(Boolean).join(" "));
+      setFooter(tr("Playing {name}.", { name: nameOf(playlist) }), success);
+      return;
+    }
+    if (action === "save") {
+      const target = words ? application.findLibraryPlaylists(words).find((playlist) => playlist.name.toLocaleLowerCase() === words.toLocaleLowerCase() || (playlist.saved && /^saved$/iu.test(words))) : null;
+      const saved = await application.saveToLibrary({ from: "now_playing", ...(target ? { playlistId: target.id } : words ? { playlistName: words } : {}) });
+      const where = saved.playlist.saved ? tr("Saved") : saved.playlist.name;
+      const text = !saved.added ? tr("Already in {name}.", { name: where }) : saved.playlist.saved ? tr("Saved.") : tr("Saved to {name}.", { name: where });
+      addMoondogMessage(text);
+      setFooter(text, success);
+      return;
+    }
+    // A playlist link: a copy in the library, and its songs in the listener's taste when they made it or say taste.
+    if (action === "import") {
+      const choice = rest.find((word) => ["taste", "no-taste"].includes(word));
+      const link = rest.filter((word) => word !== choice).join(" ").trim();
+      if (!link) throw new Error(tr("Paste a playlist link after /library import."));
+      setFooter(tr("Reading the playlist…"));
+      const imported = await application.importPlaylistFromLink({ link, ...(choice ? { taste: choice === "taste" } : {}) });
+      const counted = imported.total && imported.total > imported.added
+        ? tr("{added} of {total} songs came in.", { added: imported.added, total: imported.total })
+        : tr.n(imported.added, "{count} song came in.", "{count} songs came in.");
+      const taste = imported.taste === "added" ? tr("It now shapes your taste.")
+        : imported.taste === "failed" ? tr("It couldn't shape your taste this time.")
+          : tr("It doesn't shape your taste; add taste after the link if it should.");
+      addMoondogMessage(`${tr("Imported {name}.", { name: imported.playlist.name })} ${counted} ${taste}`);
+      setFooter(tr("Imported {name}.", { name: imported.playlist.name }), success);
+      // A playlist that shapes the taste shows the profile it now reads, as any import into the profile does.
+      if (imported.taste === "added") await openProfile({ imported: true }).catch(() => {});
+      return;
+    }
+    throw new Error(tr("Use /library, /library play <name>, /library save [playlist], or /library import <link>."));
   };
 
   const removeLifecycleListeners = () => {
@@ -730,8 +1126,11 @@ export async function runMoondogTui({
     cleanedUp = true;
     clearTimeout(watchTimer);
     stopWatchingModel?.();
+    stopModelSwitch?.();
     stopWatchingFirstRun?.();
     stopWatchingPreviews?.();
+    stopWatchingStream?.();
+    stopWatchingSetup?.();
     clearInterval(indicator);
     indicator = null;
     clearInterval(homeMotion);
@@ -760,6 +1159,8 @@ export async function runMoondogTui({
   };
 
   const shutdown = () => {
+    // A reply still running stops with the room, and so does a track it is making.
+    try { activeRuntime.abort(); } catch { /* Nothing was running. */ }
     cleanup();
     // The spoken line that closes Eclipse, the last thing on The Dark Side of the Moon.
     try {
@@ -1008,6 +1409,27 @@ export async function runMoondogTui({
     void refreshFirstRun();
     return nextStatus;
   };
+  // A model the listener asked the agent for in words, switched to as /model does once the reply ends.
+  // The terminal stays busy while it switches, so a message queued during the reply waits for the new model.
+  const applyModelAskedFor = async () => {
+    const selection = modelAskedFor;
+    modelAskedFor = null;
+    if (!selection || cleanedUp || busy) { modelAskedFor ??= selection; return; }
+    setBusy(true);
+    let status = null;
+    try {
+      status = await replaceRuntime(runtimeSelection(selection.provider, selection.model, selection.effort ?? runtimeStatus.effort)).catch(() => null);
+    } finally {
+      setBusy(false);
+    }
+    if (status?.state === "configured") setFooter(tr("Model ready."), success);
+    settleQueue();
+  };
+  const stopModelSwitch = application.modelSwitch?.subscribe?.(({ application: from, selection }) => {
+    if (from !== application) return;
+    modelAskedFor = selection;
+    if (!busy) void applyModelAskedFor();
+  });
   // The window saved another model, or a sign-in that lets this side answer. The terminal's own
   // choices rebuild at once, so their saves find this agent already on them.
   const followModel = async () => {
@@ -1804,10 +2226,11 @@ export async function runMoondogTui({
       ? tr("All set. /spotify help shows how to connect Spotify.")
       : tr("All set. Say anything, or press Tab to look around."), success);
   };
-  // The view closes at once; the saved skip then reaches the window too.
+  // The view closes at once; the saved skip then reaches the window too, and a room closed right
+  // after Esc still saves it.
   const skipFirstRun = () => {
     closeFirstRun(tr("Skipped. /service and /model are here when you want them."));
-    void firstRun.finish({ skipped: true }).catch(() => {});
+    firstRunSaving = firstRun.finish({ skipped: true }).catch(() => {});
   };
   const handleFirstRunAction = async ({ type, value } = {}) => {
     if (busy || cleanedUp || !firstRunView) return;
@@ -2089,6 +2512,8 @@ export async function runMoondogTui({
       application.locale = locale;
       // A chosen language also becomes the conversation's, so the next short reply follows it.
       application.conversationLocale = locale;
+      // A language chosen here ends one the listener asked the agent to keep.
+      application.replyLanguagePin = null;
       await saveLanguage?.(locale);
       const pinned = normalizeLocale(environment.MOONDOG_LANGUAGE);
       transcript.invalidate();
@@ -2144,6 +2569,14 @@ export async function runMoondogTui({
       await pickService(args);
       return;
     }
+    if (command === "generation") {
+      await manageGeneration(args);
+      return;
+    }
+    if (command === "library") {
+      await manageLibrary(args);
+      return;
+    }
     if (command === "spotify") {
       await runSpotifyCommand(args);
       return;
@@ -2303,6 +2736,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);
@@ -2312,7 +2751,7 @@ export async function runMoondogTui({
         setFooter(`/${command}...`);
         const argumentText = value.slice(1).trim().slice(rawCommand.length).trim();
         const parsedArgs = command === "import" ? argumentText ? [argumentText] : []
-          : ["profile", "spotify", "web"].includes(command)
+          : ["profile", "spotify", "web", "generation"].includes(command)
           ? parseTuiArguments(argumentText)
           : args;
         await runLocalCommand(command, parsedArgs);
@@ -2408,6 +2847,12 @@ export async function runMoondogTui({
           if (!cancellationRequested) setFooter(tr("Can't reach the model. Trying again ({attempt}/{max})...", { attempt, max: maxRetries }), warning);
         },
         onToolStart: (tool) => updateTool(tool, "running"),
+        // Making a track says where it is, from warming up to saving it.
+        onToolUpdate: (tool) => {
+          const stage = generationStages[tool?.stage];
+          if (cleanedUp || cancellationRequested || !stage) return;
+          setFooter(`${sanitizeTerminalText(tr.marked(tool.label ?? "Music tool"))} · ${tr.marked(stage)}...`);
+        },
         onToolEnd: (tool) => updateTool(tool, tool?.isError ? "failed" : "completed"),
         // The model names a new conversation after its first reply; the header shows that name from then on.
         onConversationNamed: ({ session_id, title }) => {
@@ -2484,9 +2929,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();
@@ -2739,6 +3186,7 @@ export async function runMoondogTui({
   } finally {
     cleanup();
     await lyricTask;
+    await firstRunSaving;
   }
   return exitRequest;
 }