@audiofool/moondog 0.3.0-beta.6 → 0.3.0-beta.8

package/src/core/listening-now.mjs

@@ -78,7 +78,8 @@ async function spotify(application, { signal }) {
 }
 
 // Moondog's own player: Apple Music songs in the window or the terminal, and the tracks Moondog made.
-const madeBy = (track) => ({ title: track.title, artists: track.generated ? ["Moondog"] : track.artist_credit ? [track.artist_credit] : [] });
+const madeBy = (track) => ({ title: track.title, artists: track.generated ? ["Moondog"] : track.artist_credit ? [track.artist_credit] : [],
+  ...(track.generated && track.id ? { made_track_id: track.id } : {}) });
 function moondogPlayer(application) {
   const now = application.musicPreviewPlayer.nowPlaying();
   if (!now?.song?.title) return { state: "stopped" };
@@ -132,7 +133,7 @@ export async function readListeningNow(application, { signal } = {}) {
 const entry = (track) => ({
   title: String(track?.title ?? "").trim(),
   artist_credit: String(track?.artist_credit ?? "").trim(),
-  ...(track?.generated === true ? { generated: true } : {}),
+  ...(track?.generated === true ? { generated: true, ...(typeof track.id === "string" && track.id ? { id: track.id } : {}) } : {}),
 });
 
 export function createPlayerNow() {
@@ -161,6 +162,10 @@ export function createPlayerNow() {
     clear() {
       queue = null;
     },
+    /** The song playing and every one after it, for keeping the whole queue: read() shows only ten. */
+    remaining() {
+      return queue ? queue.tracks.slice(queue.index).map((track) => ({ ...track })) : [];
+    },
     /** null when nothing is queued, or { state, song, position, count, next } with up to ten songs after it. */
     read() {
       if (!queue) return null;

package/src/core/moondog-application.mjs

@@ -4,7 +4,7 @@ import { setTimeout as delay } from "node:timers/promises";
 import { compactListenerProfile, readListenerProfile } from "../profile/listener-profile-build.mjs";
 import { mixCounts, songKeys } from "../profile/moondog-suggestions.mjs";
 import { ARTIST_CREDIT_SEPARATORS } from "./listener-avoids.mjs";
-import { textNamesSong } from "./track-title.mjs";
+import { foldedWords, normalizedTrackTitle, textNamesSong } from "./track-title.mjs";
 import { acceptableRecordTitle, compileTaste, tasteSources } from "../profile/taste-compiler.mjs";
 import { stableAudioPrompt } from "../integrations/stable-audio/local-generator.mjs";
 
@@ -19,9 +19,23 @@ import {
 import { recoverArtistReleasesWithCrossCatalogIdentity } from "../integrations/cross-catalog-artist-identity.mjs";
 import { webProviderName } from "../integrations/web/web-result.mjs";
 import { musicAppSource, readListeningNow } from "./listening-now.mjs";
+import { SAVED_PLAYLIST_ID } from "./library-store.mjs";
 import { normalizeConversationFolder, normalizeConversationLabel, normalizeMemoryContent, shortConversationTitle } from "../memory/local-memory-store.mjs";
 import { queueListeningIntent, queueCancellationRequested, unheardRequested } from "./spotify-listening-intent.mjs";
-import { DEFAULT_LOCALE, messageLocale, normalizeLocale } from "../i18n/index.mjs";
+import { DEFAULT_LOCALE, LOCALES, messageLocale, normalizeLocale } from "../i18n/index.mjs";
+
+// Runs work over a list with at most limit calls at once, keeping the list's order.
+async function mapLimited(list, limit, work) {
+  const results = new Array(list.length);
+  let next = 0;
+  await Promise.all(Array.from({ length: Math.min(limit, list.length) }, async () => {
+    while (next < list.length) {
+      const at = next++;
+      results[at] = await work(list[at], at);
+    }
+  }));
+  return results;
+}
 
 // How long a record's title in the wrong language waits to be named again before the agent's stays.
 const TITLE_LANGUAGE_TIMEOUT_MS = 10_000;
@@ -239,10 +253,14 @@ export class MoondogApplication {
     musicCatalog = null,
     musicSimilarity = null,
     musicPreviewPlayer = null,
+    languageSelection = null,
+    modelSwitch = null,
     neteasePlayer = null,
     localGenerator = null,
     atmosphereStream = null,
     musicApp = null,
+    // The listener's library (src/core/library-store.mjs), shared by every conversation and both surfaces.
+    libraryStore = null,
     agentHostNotes = [],
     artistIdentityResolver = null,
     webResearch = null,
@@ -266,6 +284,7 @@ export class MoondogApplication {
     // The language of the conversation so far. A reply such as "2" or "ok" carries none of
     // its own, so it keeps this one rather than switching to the setting mid-conversation.
     this.conversationLocale = null;
+    this.replyLanguagePin = null;
     this.domainServices = domainServices;
     this.domainServicesError =
       typeof domainServicesError === "string" &&
@@ -285,6 +304,10 @@ export class MoondogApplication {
     // Hosts that can play audio pass { play(tracks, { album }) }: the website, and the
     // terminal when the system has a player.
     this.musicPreviewPlayer = musicPreviewPlayer;
+    // Shared with every surface and conversation of this core, so a language chosen in words is saved and shown everywhere.
+    this.languageSelection = languageSelection;
+    // The listener's model menu, and the way a model asked for in words reaches the surface that runs this agent.
+    this.modelSwitch = modelSwitch;
     // NetEase Cloud Music through ncm-cli (src/integrations/netease), shared by every conversation.
     this.neteasePlayer = neteasePlayer;
     // Stable Audio 3 on this Mac (src/integrations/stable-audio), shared by every conversation, so one track is made at a time.
@@ -294,6 +317,7 @@ export class MoondogApplication {
     // The Music app on this Mac (src/integrations/apple-music/music-app.mjs), read for what the
     // listener plays there themselves.
     this.musicApp = musicApp;
+    this.libraryStore = libraryStore;
     // Hosts can tell the agent where it runs; the terminal passes none.
     this.hostNotes = Array.isArray(agentHostNotes) ? agentHostNotes.filter((note) => typeof note === "string") : [];
     this.artistIdentityResolver = artistIdentityResolver;
@@ -598,6 +622,210 @@ export class MoondogApplication {
     return { state: "playing", track: { id, title, seconds: receipt.audio?.duration_seconds ?? null }, chosen_by: named ? "listener" : "moondog" };
   }
 
+  // The listener's library: their playlists and the songs and made tracks they kept, side by side.
+  libraryReady() {
+    return Boolean(this.libraryStore);
+  }
+
+  requireLibrary() {
+    if (!this.libraryStore) throw Object.assign(new Error("The library is not available here."), { code: "library_not_ready" });
+    return this.libraryStore;
+  }
+
+  libraryView() {
+    return this.libraryReady() ? this.libraryStore.view() : null;
+  }
+
+  // One playlist with its entries; a made track says whether its audio is still on this Mac.
+  async libraryPlaylist(id) {
+    const playlist = this.requireLibrary().playlist(id);
+    if (!playlist) return null;
+    for (const entry of playlist.entries) {
+      if (entry.kind === "made") entry.audio_kept = Boolean(await this.localGenerator?.trackFile?.(entry.made_id));
+    }
+    return playlist;
+  }
+
+  // The song or made track one listening source plays now, as a library entry.
+  #entryOfSong(song) {
+    if (!song?.title) return null;
+    if (song.made_track_id) return { kind: "made", id: song.made_track_id, title: song.title };
+    const artist = Array.isArray(song.artists) ? song.artists.join(", ") : "";
+    if (!artist) return null;
+    const album = typeof song.album === "string" ? song.album : song.album?.name;
+    return { kind: "song", title: song.title, artist_credit: artist, ...(album ? { album } : {}) };
+  }
+
+  // What to save: the song playing now, what plays from now on (its playlist or queue), songs the agent names,
+  // or a made track by id.
+  async #entriesToSave({ from, songs, madeTrackId }, { signal } = {}) {
+    if (madeTrackId) {
+      const receipt = await this.localGenerator?.receipt?.(madeTrackId);
+      if (!receipt) throw Object.assign(new Error("There is no track Moondog made with that id on this Mac."), { code: "made_track_not_found" });
+      if (!(await this.localGenerator.trackFile(madeTrackId))) {
+        throw Object.assign(new Error("Only the receipt of that track is left, so it can't be kept."), { code: "made_track_audio_not_kept" });
+      }
+      return [{ kind: "made", id: madeTrackId, title: String(receipt.title ?? "Moondog") }];
+    }
+    if (Array.isArray(songs) && songs.length) {
+      return songs.map((song) => ({ kind: "song", title: song.title, artist_credit: song.artist ?? song.artist_credit, ...(song.album ? { album: song.album } : {}) }));
+    }
+    const now = await readListeningNow(this, { signal });
+    const active = now.sources.find((source) => source.service === now.active);
+    if (!active?.song) throw Object.assign(new Error("Nothing is playing, so there is nothing to save."), { code: "library_nothing_playing" });
+    if (from === "queue") {
+      // What plays from now on: Moondog's whole remaining queue (its status shows only the next ten); the Music
+      // app's playlist from the song playing, which it places; otherwise the song and the service's own queue.
+      const remaining = active.service === "moondog" ? this.musicPreviewPlayer?.remaining?.() : null;
+      let playing = active.from;
+      // The Music app's status reads a window around the playing song; a longer playlist is read on to its end.
+      if (active.service === "apple_music" && playing?.tracks?.length && Number.isInteger(playing.tracks_total) &&
+          (playing.first_position ?? 1) - 1 + playing.tracks.length < playing.tracks_total && typeof this.musicApp?.remainingPlaylist === "function") {
+        const rest = await this.musicApp.remainingPlaylist().then((now) => musicAppSource(now).from, () => null);
+        if (rest?.tracks?.length && Number.isInteger(rest.position) && Number.isInteger(rest.first_position)) playing = rest;
+      }
+      const tracks = playing?.tracks;
+      const placed = tracks?.length && Number.isInteger(playing.position) && Number.isInteger(playing.first_position);
+      const list = remaining?.length ? remaining.map((track) => ({ title: track.title, artists: track.generated ? ["Moondog"] : [track.artist_credit].filter(Boolean),
+        ...(track.generated && track.id ? { made_track_id: track.id } : {}) }))
+        : placed ? tracks.slice(Math.max(0, playing.position - playing.first_position))
+          : [active.song, ...(active.next ?? [])];
+      return list.map((song) => this.#entryOfSong(song)).filter(Boolean);
+    }
+    const one = this.#entryOfSong(active.song);
+    if (!one) throw Object.assign(new Error("The song playing now has no artist to keep it by."), { code: "library_nothing_playing" });
+    return [one];
+  }
+
+  /**
+   * Keeps songs or made tracks in the library: in Saved when no playlist is named, in a playlist by id, or
+   * in a new playlist by name. by says who chose to keep them: the listener, or Moondog at their request.
+   */
+  async saveToLibrary({ from = "now_playing", songs, madeTrackId, playlistId, playlistName, folderId, artwork } = {}, { by = "listener", signal } = {}) {
+    const library = this.requireLibrary();
+    const entries = await this.#entriesToSave({ from, songs, madeTrackId }, { signal });
+    if (!entries.length) throw Object.assign(new Error("There is nothing to save."), { code: "library_nothing_playing" });
+    // The window passes the cover it shows for the song playing now.
+    if (artwork && from === "now_playing" && !songs?.length && !madeTrackId && entries[0].kind === "song") entries[0].refs = { artwork_url: artwork };
+    if (!playlistId && playlistName) {
+      const made = library.savePlaylist({ name: playlistName, folderId: folderId ?? null, origin: by === "moondog" ? "moondog" : "listener", entries, addedBy: by });
+      return { playlist: { id: made.id, name: library.playlist(made.id).name, created: true }, added: made.added, already: made.already,
+        titles: entries.map((entry) => entry.title) };
+    }
+    const target = playlistId ?? SAVED_PLAYLIST_ID;
+    const added = library.addEntries(target, entries, { addedBy: by });
+    const playlist = library.playlist(target);
+    return { playlist: { id: playlist.id, name: playlist.saved ? "Saved" : playlist.name, ...(playlist.saved ? { saved: true } : {}) },
+      added: added.added, already: added.already, titles: entries.map((entry) => entry.title) };
+  }
+
+  /** Playlists by name for the agent, or the newest ones when no words are given. */
+  findLibraryPlaylists(query) {
+    return this.requireLibrary().findPlaylists(query).map(({ id, name, count, made, origin, saved }) => ({
+      id, name: saved ? "Saved" : name, count, made, origin, ...(saved ? { saved: true } : {}) }));
+  }
+
+  /**
+   * Plays a playlist from the library, from its first entry or from one entry. It plays on the listener's
+   * chosen service: Moondog's own player holds Apple Music songs and made tracks in one queue; Spotify and
+   * NetEase play its songs, and its made tracks wait for Moondog's own player (left_out_made says how many).
+   * The listener's own playlist is their pick, so nothing of it goes in the suggestions ledger.
+   */
+  async playLibrary({ playlistId, entryId, shuffle = false } = {}, { signal } = {}) {
+    const playlist = await this.libraryPlaylist(playlistId);
+    if (!playlist) throw Object.assign(new Error("That playlist is not in the library."), { code: "library_playlist_not_found" });
+    const named = { id: playlist.id, name: playlist.saved ? "Saved" : playlist.name };
+    let entries = playlist.entries;
+    const start = entryId ? entries.findIndex((entry) => entry.id === entryId) : 0;
+    entries = entries.slice(Math.max(0, start));
+    if (shuffle) entries = entries.map((entry) => [Math.random(), entry]).sort((a, b) => a[0] - b[0]).map(([, entry]) => entry);
+    const avoided = entries.filter((entry) => entry.kind === "song" && !this.avoidAllows({ title: entry.title, artist_credit: entry.artist_credit }));
+    entries = entries.filter((entry) => !avoided.includes(entry) && (entry.kind === "song" || entry.audio_kept));
+    const extra = avoided.length ? { skipped_avoided_count: avoided.length } : {};
+    if (!entries.length) return { state: "empty", playlist: named, ...extra };
+    const songs = entries.filter((entry) => entry.kind === "song");
+    const service = this.playbackService;
+    // Only made tracks, or Apple Music chosen: Moondog's own player, with both in one queue.
+    if ((!songs.length || service === "apple_music") && typeof this.musicPreviewPlayer?.playList === "function") {
+      const refs = [];
+      const avoidedFound = [];
+      const found = await mapLimited(entries.slice(0, 50), 6, async (entry) => {
+        if (entry.kind === "made") return { generated: true, id: entry.made_id, title: entry.title, file: await this.localGenerator.trackFile(entry.made_id) };
+        if (!this.musicCatalog) return null;
+        const result = await this.musicCatalog.findPreview({ title: entry.title, artist: entry.artist_credit }).catch(() => null);
+        if (result?.state !== "resolved") return null;
+        // The catalog's recording can credit more than the entry named (a feature, a longer title); an Avoid still holds.
+        if (!this.avoidAllows(result.track)) { avoidedFound.push(entry.id); return null; }
+        if (result.track.catalog_id) refs.push({ entryId: entry.id, refs: { apple_music_id: String(result.track.catalog_id),
+          ...(entry.refs?.artwork_url || !result.track.artwork_url ? {} : { artwork_url: result.track.artwork_url }) } });
+        return result.track;
+      });
+      signal?.throwIfAborted();
+      const tracks = found.filter(Boolean);
+      const notFound = found.length - tracks.length - avoidedFound.length;
+      const skipped = avoided.length + avoidedFound.length;
+      Object.assign(extra, skipped ? { skipped_avoided_count: skipped } : {});
+      if (!tracks.length) return { state: "not_found", playlist: named, not_found: notFound, ...extra };
+      this.libraryStore.rememberRefs(refs);
+      // A playlist replaces Moondog's stream and quiets the other players, as any music Moondog starts does.
+      await this.#endStream("replaced");
+      await this.quietOtherPlayers("apple_music", { signal });
+      signal?.throwIfAborted();
+      this.musicPreviewPlayer.playList(tracks);
+      return { state: "playing", player: "moondog", playlist: named, playing: tracks.length, not_found: notFound,
+        whole_songs: this.musicPreviewPlayer.wholeSongs?.() === true, ...extra };
+    }
+    const leftOut = entries.length - songs.length;
+    if (service === "spotify") {
+      if (!this.spotifyPlaybackReady()) throw Object.assign(new Error("Spotify is not ready to play here."), { code: "spotify_not_ready" });
+      const list = songs.slice(0, 100);
+      const refs = [];
+      const avoidedFound = [];
+      // A recording's own title and credit can name more than the entry does (a feature); an Avoid holds against it.
+      const allowed = (title, credit) => this.avoidAllows({ title, artist_credit: credit });
+      const uris = await mapLimited(list, 4, async (entry) => {
+        // A cached recording plays without a search, once its own credit passes today's Avoids.
+        if (entry.refs?.spotify_uri && entry.refs.spotify_credit) {
+          if (allowed(entry.refs.spotify_title ?? entry.title, entry.refs.spotify_credit)) return entry.refs.spotify_uri;
+          avoidedFound.push(entry.id);
+          return null;
+        }
+        const { matched } = await this.spotifyResolveSongs([{ title: entry.title, artist: entry.artist_credit }], { signal }).catch(() => ({ matched: [] }));
+        // A match reaches the model without its URI; the host keeps it under the match's reference.
+        const ref = matched[0]?.item_ref_id;
+        const known = ref ? this.spotifyHostReadItems().find((item) => item.item_ref_id === ref) : null;
+        const uri = typeof known?.uri === "string" ? known.uri : typeof matched[0]?.uri === "string" ? matched[0].uri : null;
+        if (!uri) return null;
+        const title = known?.name ?? matched[0]?.name ?? entry.title;
+        const credit = (known?.artists ?? matched[0]?.artists ?? []).join(", ") || entry.artist_credit;
+        refs.push({ entryId: entry.id, refs: { spotify_uri: uri, spotify_title: title, spotify_credit: credit } });
+        if (!allowed(title, credit)) { avoidedFound.push(entry.id); return null; }
+        return uri;
+      });
+      signal?.throwIfAborted();
+      this.libraryStore.rememberRefs(refs);
+      const playable = uris.filter(Boolean);
+      const skipped = avoided.length + avoidedFound.length;
+      Object.assign(extra, skipped ? { skipped_avoided_count: skipped } : {});
+      const unfound = list.length - playable.length - avoidedFound.length;
+      if (!playable.length) return { state: "not_found", playlist: named, not_found: unfound, left_out_made: leftOut, ...extra };
+      await this.quietOtherPlayers("spotify", { signal });
+      const receipt = await this.#resumeSpotifySelection({ uris: playable }, { signal, played: [] });
+      return { state: receipt.state === "accepted" ? "playing" : receipt.state, player: "spotify", playlist: named, playing: playable.length,
+        not_found: unfound, left_out_made: leftOut, ...extra };
+    }
+    if (service === "netease" && this.neteaseReady()) {
+      const player = this.requireNetease();
+      await this.quietOtherPlayers("netease", { signal });
+      const receipt = await player.play({ items: songs.slice(0, 20).map((entry) => ({ title: entry.title, artist: entry.artist_credit })), mode: "play",
+        intent: "播放听者自己的歌单", allow: (song) => this.avoidAllows(Array.isArray(song.artists)
+          ? { title: song.title, artist_credit: song.artists.join(", "), artists: song.artists } : song) });
+      return { state: receipt?.mode === "playing" ? "playing" : "not_found", player: "netease", playlist: named,
+        playing: receipt?.songs?.length ?? 0, left_out_made: leftOut, ...extra };
+    }
+    throw Object.assign(new Error("No player here can play this playlist."), { code: "library_no_player" });
+  }
+
   // Makes one instrumental track from the listener's taste and plays it in Moondog's own player.
   // The agent proposes sound descriptors, each with its source; the taste compiler keeps only the
   // ones it can trace and none that names an artist or a song. The track and its receipt stay on
@@ -938,6 +1166,52 @@ export class MoondogApplication {
     return this.playbackSelection.subscribe(listener);
   }
 
+  // What the agent can tell the listener about its own setup, and what it can change when asked.
+  async settingsStatus(runtime = {}) {
+    const playback = this.playbackStatus();
+    const choices = await this.modelSwitch?.choices().catch(() => []) ?? [];
+    return {
+      model: { provider: runtime.provider ?? null, model: runtime.model ?? null, ...(runtime.effort ? { effort: runtime.effort } : {}),
+        ...(this.modelSwitch ? { change: "moondog_settings model", choices } : { change: "not_by_agent" }),
+        where: "Settings › Models in the window, or /model in the terminal" },
+      music_service: { selected: playback.selected_service ?? null, effective: playback.effective_service ?? null,
+        available: (playback.services ?? []).filter((entry) => entry.available).map((entry) => entry.service),
+        change: "moondog_playback_service" },
+      reply_language: { current: this.locale, choices: Object.keys(LOCALES), change: "moondog_settings reply_language" },
+    };
+  }
+
+  // The reply language the listener asked for in words: used from the next reply on, saved like
+  // the language picker's choice, and shown by each surface.
+  async setReplyLanguage(code, runtime = {}) {
+    const locale = normalizeLocale(code);
+    if (!locale) throw Object.assign(new Error("Unsupported reply language."), { code: "unsupported_reply_language" });
+    const previous = this.locale;
+    this.locale = locale;
+    this.conversationLocale = locale;
+    // Asked for in words, the language holds in this conversation whatever language the listener writes in.
+    this.replyLanguagePin = locale;
+    await this.languageSelection?.change(locale);
+    return { ...await this.settingsStatus(runtime), changed: { setting: "reply_language", from: previous, to: locale } };
+  }
+
+  // A model the listener asked for in words, from their model menu: by provider/model, model ID or
+  // name. It takes over when this reply ends; a model not set up, or not signed in, is refused.
+  async requestModel(wanted, runtime = {}) {
+    if (!this.modelSwitch) throw Object.assign(new Error("This host cannot change the model from a conversation."), { code: "model_change_unavailable" });
+    const choices = await this.modelSwitch.choices();
+    const key = String(wanted ?? "").trim().toLowerCase();
+    const folded = (value) => String(value).toLowerCase().replace(/[^\p{L}\p{N}]+/gu, "");
+    const match = choices.find((choice) => choice.model.toLowerCase() === key) ??
+      choices.find((choice) => choice.model.split("/").slice(1).join("/").toLowerCase() === key) ??
+      choices.find((choice) => folded(choice.name) === folded(key));
+    if (!match) throw Object.assign(new Error(`That model is not in the listener's model menu. Choose one of: ${choices.map((choice) => choice.model).join(", ") || "none"}. Others are added in Settings › Models or with /model.`), { code: "model_not_listed" });
+    if (!match.ready) throw Object.assign(new Error(`${match.model} is in the menu but not signed in. The listener signs in from Settings › Models or with /auth.`), { code: "model_not_signed_in" });
+    const [provider, ...rest] = match.model.split("/");
+    this.modelSwitch.request(this, { provider, model: rest.join("/") });
+    return { ...await this.settingsStatus(runtime), changed: { setting: "model", from: `${runtime.provider}/${runtime.model}`, to: match.model, takes_effect: "after this reply" } };
+  }
+
   // A host-only in-memory change, kept for hosts with no saved settings.
   setPlaybackService(service) {
     return this.playbackSelection.set(service);
@@ -2073,6 +2347,43 @@ export class MoondogApplication {
       truncated: result.truncated === true || raw.length > 10 };
   }
 
+  // Songs the listener named, by title and artist: the host searches Spotify for each one and
+  // keeps the result whose artist and title match, so the model passes no references and makes
+  // no second call. A song without a clear match is never guessed; its closest results come back
+  // with item_ref_id values, to choose from and play by reference.
+  async spotifyResolveSongs(songs, { signal, otherSources = [] } = {}) {
+    // Songs and a reference together are two choices of what to play; neither wins silently.
+    if (otherSources.length) throw spotifyResolutionError("spotify_playback_source_conflict", "Choose one playback source for resume: songs, or one reference. Nothing was played.");
+    if (!Array.isArray(songs) || songs.length < 1 || songs.length > 12 ||
+        songs.some((song) => typeof song?.title !== "string" || !song.title.trim() || typeof song?.artist !== "string" || !song.artist.trim())) {
+      throw spotifyResolutionError("invalid_spotify_songs", "Give from 1 to 12 songs, each with a title and an artist.");
+    }
+    const fold = (value) => foldedWords(normalizedTrackTitle(value));
+    const matched = [];
+    const unmatched = [];
+    for (const song of songs) {
+      const result = await this.spotifySearchTracks({ query: `${song.title} ${song.artist}`, type: "track", limit: 10 }, { signal });
+      const tracks = result.items.filter((item) => item.type === "track" && item.track_ref_id);
+      const wantedTitle = foldedWords(song.title);
+      const wantedCore = fold(song.title);
+      // The same artist: equal names, or one credited artist of a joint credit ("伍佰" in
+      // "伍佰 & China Blue"). A name inside another act's name ("Adele Tribute Band") is another act.
+      const credited = (name) => [name, ...String(name).split(ARTIST_CREDIT_SEPARATORS)].map(foldedWords).filter(Boolean);
+      const wantedArtists = new Set(credited(song.artist));
+      const byArtist = tracks.filter((item) => item.artists.some((artist) => credited(artist).some((name) => wantedArtists.has(name))));
+      // The exact title first. A version the listener named (a live take, a duet) must match as
+      // named; otherwise the same song in another version (a remaster) is the song asked for.
+      // Nothing looser is guessed: a shared prefix ("One", "One Tree Hill") is another song.
+      const versionNamed = wantedTitle !== wantedCore;
+      const pick = byArtist.find((item) => foldedWords(item.name) === wantedTitle) ??
+        (versionNamed ? undefined : byArtist.find((item) => fold(item.name) === wantedCore));
+      if (pick) matched.push(pick);
+      else unmatched.push({ title: song.title, artist: song.artist,
+        candidates: tracks.slice(0, 5).map(({ item_ref_id, name, artists, album }) => ({ item_ref_id, name, artists, ...(album ? { album } : {}) })) });
+    }
+    return { matched, unmatched };
+  }
+
   spotifyDiscoveryAllowed(item) {
     return this.avoidAllows({ title: item.name, artist_credit: item.artists.join(", "), artists: item.artists });
   }
@@ -2196,7 +2507,18 @@ export class MoondogApplication {
     // named in their language; otherwise a sensible batch from the candidates.
     const requested = intent?.requested ?? count ?? Math.min(itemRefs.length, 12);
     if (!Number.isInteger(requested) || requested < 1 || requested > 12) throw spotifyResolutionError("spotify_queue_count_limit", "A queue request supports 1 to 12 songs. No write was sent.");
-    const items = itemRefs.map(ref => this.requireSpotifyReadItem(ref, ["track"]));
+    // A reference the host never issued (a model's slip) is left out and counted; only a batch
+    // with no usable reference at all is refused.
+    const chosen = itemRefs.map((ref) => { try { return this.requireSpotifyReadItem(ref, ["track"]); } catch { return null; } }).filter(Boolean);
+    const skippedUnavailable = itemRefs.length - chosen.length;
+    if (!chosen.length) this.requireSpotifyReadItem(itemRefs[0], ["track"]);
+    // The rest of this request's verified discovery results by the artists the model picked stand
+    // behind its picks, in the order found, so a pick skipped as a duplicate or an Avoid still
+    // leaves the count asked for. A song by another artist may have been left out on purpose.
+    const pickedArtists = new Set(chosen.flatMap(item => item.artists));
+    const backups = transaction.discoveryPoolStarted ? (this.spotifyReadSelections.get("discovery") ?? [])
+      .filter(item => item.type === "track" && item.uri && !itemRefs.includes(item.item_ref_id) && item.artists.some(artist => pickedArtists.has(artist))) : [];
+    const items = [...chosen, ...backups].slice(0, 36);
     this.requireSpotifyWriteScopes(["user-modify-playback-state"]);
     this.requireSpotifyScopes(["user-read-playback-state"]);
     transaction.queueBatchAttempted = true;
@@ -2221,9 +2543,12 @@ export class MoondogApplication {
       knownTrack: intent?.excludeKnown ? track => this.domainServices?.isKnownDiscoveryTrack?.(track) === true : null });
     if (!receipt.queued.length && !receipt.stopped) transaction.queueBatchAttempted = false;
     const result = { ...receipt, action: "queue.batch", requested, queued_count: receipt.queued.length,
-      shortfall: requested - receipt.queued.length, queue_observation_truncated: observed.truncated === true };
+      shortfall: requested - receipt.queued.length, queue_observation_truncated: observed.truncated === true,
+      ...(skippedUnavailable ? { skipped_unavailable_count: skippedUnavailable } : {}) };
     this.spotifyDisplayedChoices = null;
     if (this.spotifyQueueRequest && (receipt.queued.length || receipt.stopped)) Object.assign(this.spotifyQueueRequest, { attempted: true, receipt: structuredClone(result) });
+    // Kept on the request itself, so a fill finds the batch even when no queue intent was parsed.
+    if (receipt.queued.length) transaction.batchReceipt = structuredClone(result);
     return result;
   }
 
@@ -2347,7 +2672,24 @@ export class MoondogApplication {
 
   async spotifyAddToQueue(input, { signal } = {}) {
     signal?.throwIfAborted();
-    this.requireSpotifyNonRemovalAction();
+    // A batch that came up short may be filled by single adds of songs it did not queue, one per
+    // missing song; anything else after a batch is refused as before.
+    const transaction = this.pendingPlaylistPromptTransaction;
+    const batch = transaction?.queueBatchAttempted && transaction.batchReceipt?.action === "queue.batch" ? transaction.batchReceipt : null;
+    // The retained receipt takes in each accepted fill, so its queued songs are the count so far.
+    const missing = batch ? (batch.requested ?? 0) - (batch.queued?.length ?? 0) : 0;
+    // Either supported reference names the song: a read's item_ref_id, or a retained or resolved track_ref_id.
+    const fillRef = input?.itemRefId ?? input?.trackRefId;
+    const resolved = batch && input?.trackRefId !== undefined ? this.spotifyResolutions.get(input.trackRefId) : null;
+    const candidate = !batch || fillRef === undefined ? null
+      : this.spotifyHostReadItems().find((entry) => entry.item_ref_id === fillRef || entry.track_ref_id === fillRef) ??
+        (resolved?.uri ? { type: "track", uri: resolved.uri, name: resolved.matched?.title ?? "", artists: resolved.matched?.artists ?? [] } : null);
+    // The same song is the same title by the same primary artist, as the batch itself decides.
+    const candidateSongs = candidate ? songKeys({ title: candidate.name, artist_credit: candidate.artists?.join(", ") ?? "", artists: candidate.artists ?? [] }) : [];
+    const fillsBatch = missing > 0 && candidate?.type === "track" &&
+      !batch.queued.some((queued) => songKeys(queued).some((key) => candidateSongs.includes(key))) &&
+      !(transaction.batchFillUris ?? []).includes(candidate.uri);
+    this.requireSpotifyNonRemovalAction({ batchFill: fillsBatch });
     let uri;
     if (input?.itemRefId !== undefined) {
       if (input.trackRefId !== undefined || input.uri !== undefined) throw spotifyResolutionError("spotify_queue_selection_conflict", "Choose one queue item.");
@@ -2360,11 +2702,37 @@ export class MoondogApplication {
     const item = this.spotifyHostReadItems().find(item => item.uri === uri);
     if (item && !this.#spotifyItemAllowed(item)) throw listenerAvoidError();
     const track = { track_ref_id: "single", title: item?.name ?? "the selected track", artist_credit: item?.artists?.join(", ") ?? "", artists: item?.artists ?? [], ...(item?.isrc ? { isrc: item.isrc } : {}) };
+    // A fill keeps the batch's own rules: nothing already in Spotify's queue or playing, and only
+    // unheard songs when the listener asked for those.
+    let fillRules = {};
+    if (fillsBatch) {
+      const service = this.requireSpotifyService();
+      const [observed, player] = await Promise.all([service.queue({ signal }), service.currentPlayer({ signal }).catch(() => null)]);
+      signal?.throwIfAborted();
+      const seenUris = this.#observedQueueUris(observed, player);
+      if (player?.item?.uri) seenUris.add(player.item.uri);
+      fillRules = { seenUris, ...(transaction.queueIntent?.excludeKnown ? { knownTrack: (entry) => this.domainServices?.isKnownDiscoveryTrack?.(entry) === true } : {}) };
+    }
     // One entry takes the same path as a batch: one device decision, start
     // playback when nothing is playing, and a check of Spotify's real queue.
-    const receipt = await this.#queueSpotifyTracks([track], new Map([["single", uri]]), { signal, deviceId: input.deviceId, rethrow: true });
+    const receipt = await this.#queueSpotifyTracks([track], new Map([["single", uri]]), { signal, deviceId: input.deviceId, rethrow: true, ...fillRules });
+    if (fillsBatch && !receipt.queued.length) {
+      throw spotifyResolutionError("spotify_queue_fill_skipped", receipt.skipped_known_count
+        ? "That song is one the listener already knows, and they asked for unheard songs only. Nothing was queued."
+        : "That song is already in Spotify's queue or playing. Nothing was queued; choose another song for the missing place.");
+    }
     this.recentSimilarQueueUris.set(uri, Date.now());
     while (this.recentSimilarQueueUris.size > 100) this.recentSimilarQueueUris.delete(this.recentSimilarQueueUris.keys().next().value);
+    if (fillsBatch) {
+      transaction.batchFillUris = [...(transaction.batchFillUris ?? []), uri];
+      // The receipt a later "queue, not playlist" reply shows says what is queued now.
+      for (const kept of [batch, this.spotifyQueueRequest?.receipt?.action === "queue.batch" ? this.spotifyQueueRequest.receipt : null]) {
+        if (!kept) continue;
+        kept.queued = [...kept.queued, ...receipt.queued];
+        kept.queued_count = kept.queued.length;
+        kept.shortfall = Math.max(0, (kept.requested ?? 0) - kept.queued.length);
+      }
+    }
     return { provider: "spotify", ok: true, effect: "write_external", action: "playback.queue.add", state: "accepted",
       ...(item?.name ? { targets: [{ title: item.name, artist_credit: item.artists.join(", ") }] } : {}),
       ...(receipt.device ? { device: receipt.device } : {}), ...(receipt.started_playback ? { started_playback: true } : {}),
@@ -2500,12 +2868,12 @@ export class MoondogApplication {
     }
   }
 
-  requireSpotifyNonRemovalAction({ quickEdit = false } = {}) {
+  requireSpotifyNonRemovalAction({ quickEdit = false, batchFill = false } = {}) {
     const requested = this.pendingPlaylistPromptTransaction?.queueIntent?.requested;
     if (requested != null && (!Number.isInteger(requested) || requested < 1 || requested > 12)) {
       throw spotifyResolutionError("spotify_queue_count_limit", "Specify one exact queue count from 1 to 12 songs. No write was sent.");
     }
-    if (this.pendingPlaylistPromptTransaction?.queueBatchAttempted) throw spotifyResolutionError("spotify_queue_batch_already_attempted", "The requested queue batch was already attempted. Keep its receipt; do not replay or add another action.");
+    if (this.pendingPlaylistPromptTransaction?.queueBatchAttempted && !batchFill) throw spotifyResolutionError("spotify_queue_batch_already_attempted", "The requested queue batch was already attempted. Keep its receipt; do not replay or add another action.");
     if (this.pendingPlaylistPromptTransaction?.quickEditIntent && !quickEdit) {
       throw spotifyResolutionError("spotify_quick_edit_action_conflict", "This request authorizes only its exact quick playlist edit. An earlier preview or another Spotify action needs its own explicit request.");
     }
@@ -3617,7 +3985,8 @@ export class MoondogApplication {
       musicPreviewReady: this.musicPreviewReady(),
       tasteChoicesReady: this.tasteChoicesReady(),
       localGenerationReady: this.localGenerationReady(),
-    }).filter(descriptor => !this.#playbackServiceExcludes(descriptor.capability_id));
+    }).filter(descriptor => !this.#playbackServiceExcludes(descriptor.capability_id) &&
+      (this.libraryReady() || !descriptor.capability_id.startsWith("collection.")));
   }
 
   async findArtistReleases(input) {
@@ -4008,7 +4377,7 @@ export class MoondogApplication {
       this.pendingPlaylistPromptTransaction = null;
     } finally {
       const owned = this.ownsServices
-        ? [this.memoryStore, this.domainServices, this.musicCatalog, this.musicSimilarity, this.musicPreviewPlayer, this.webResearch]
+        ? [this.memoryStore, this.libraryStore, this.domainServices, this.musicCatalog, this.musicSimilarity, this.musicPreviewPlayer, this.webResearch]
         : [this.domainServices];
       for (const service of owned) service?.close?.();
     }

package/src/i18n/index.mjs

@@ -134,6 +134,7 @@ const WORDS = {
     "künstler", "lautsprecher", "handy", "fernseher", "pausiere", "stoppe", "überspringe", "weiter", "zurück", "lauter",
     "leiser", "welche", "welcher", "welches", "heute", "abend", "oder", "aber", "sehr", "gut", "mal", "doch", "gern", "gerne"]),
   it: new Set(["il", "gli", "di", "della", "delle", "dello", "degli", "dei", "che", "per", "metti", "mettimi", "mettere", "suona",
+    "sposta", "spostare", "spostato", "trasferisci", "sul", "sulla", "sullo", "sui", "sugli", "ho", "hai", "fatto", "riproduzione",
     "suonami", "suonare", "riproduci", "aggiungi", "canzone", "canzoni", "brano", "brani", "coda", "qualcosa", "ancora",
     "grazie", "ciao", "favore", "ascoltare", "ascolta", "prossima", "prossimo", "chi", "perché", "sono", "è", "voglio",
     "vorrei", "puoi", "fammi", "dammi", "altra", "altro", "adesso", "anche", "molto", "bene", "mio", "mia", "miei", "mie",
@@ -148,7 +149,7 @@ const COMMANDS = {
   pt: new Set(["coloca", "coloque", "toque", "adiciona", "adicione", "bota", "põe", "procura", "mostra", "recomenda", "faz", "quero", "pula", "me"]),
   fr: new Set(["mets", "joue", "lance", "ajoute", "trouve", "cherche", "montre", "donne", "recommande", "propose", "fais", "arrête", "écoute", "je", "peux", "est"]),
   de: new Set(["spiel", "spiele", "füge", "füg", "gib", "zeig", "zeige", "suche", "finde", "mach", "empfiehl", "stell", "setz", "leg", "überspringe", "pausiere", "stoppe", "ich", "kannst", "bitte"]),
-  it: new Set(["metti", "mettimi", "suona", "suonami", "riproduci", "aggiungi", "trova", "consiglia", "consigliami", "fammi", "dammi", "fai", "proponi", "ferma", "voglio", "vorrei", "ascolta", "puoi"]),
+  it: new Set(["metti", "mettimi", "suona", "suonami", "riproduci", "aggiungi", "sposta", "trasferisci", "trova", "consiglia", "consigliami", "fammi", "dammi", "fai", "proponi", "ferma", "voglio", "vorrei", "ascolta", "puoi"]),
 };
 // Letters only one language writes are strong evidence; letters several share are weak evidence for each.
 const MARKS = [
@@ -179,13 +180,15 @@ function explicitLocale(prose) {
  * message's own script and words, then the listener's configured language.
  * Quoted titles never decide it, because song names travel across languages.
  */
-export function messageLocale(text, fallback = DEFAULT_LOCALE) {
+// explicit: false reads only the language a text is written in, for Moondog's own replies, where
+// "I'll answer in Spanish" is not a request.
+export function messageLocale(text, fallback = DEFAULT_LOCALE, { explicit: readRequest = true } = {}) {
   const configured = normalizeLocale(fallback) ?? DEFAULT_LOCALE;
   if (typeof text !== "string") return configured;
   const prose = text
     .replace(/^(?:Track|Artist): "(?:[^"\\\n]|\\.)*"[ \t]*$/gmu, "")
     .replace(/"(?:[^"\\]|\\.)*"|“[^”]*”|«[^»]*»|「[^」]*」|『[^』]*』|《[^》]*》/gu, "");
-  const explicit = explicitLocale(prose);
+  const explicit = readRequest ? explicitLocale(prose) : null;
   if (explicit) return explicit;
   // Hangul is only Korean and kana only Japanese; whichever the message uses more decides.
   const hangul = prose.match(/\p{Script=Hangul}/gu)?.length ?? 0;

package/src/i18n/preferences.mjs

@@ -32,3 +32,27 @@ export async function writeLanguagePreference(locale, environment = process.env)
 export async function resolveListenerLocale(environment = process.env) {
   return normalizeLocale(environment.MOONDOG_LANGUAGE) ?? await readLanguagePreference(environment) ?? systemLocale(environment);
 }
+
+/**
+ * The reply language every surface and conversation of one core shares. A change, from the
+ * language picker or from the agent when the listener asks in words, is saved once and heard by
+ * each surface that shows the language.
+ */
+export function createLanguageSelection({ save } = {}) {
+  const listeners = new Set();
+  return {
+    async change(locale) {
+      const value = normalizeLocale(locale);
+      if (!value) throw new Error(`Unsupported language: ${locale}`);
+      await save?.(value);
+      for (const listener of listeners) {
+        try { listener(value); } catch { /* A surface cannot undo a saved choice. */ }
+      }
+      return value;
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+  };
+}