@audiofool/moondog 0.1.0 → 0.2.0-beta.2

package/src/i18n/messages/de.mjs

@@ -0,0 +1,128 @@
+// Deutsch. Keys match messages/en.mjs; a missing key falls back to English.
+export default {
+  "discovery.reason.listenbrainz": ({ adjacent, seed, release }) => `Hördaten von ListenBrainz verbinden ${adjacent} mit ${seed}; aus „${release}“.`,
+  "discovery.reason.appleMusic": ({ queries, release, genre }) => `Apple-Music-Katalog: ${queries ? `Treffer für ${queries}` : "Kandidat"}; aus „${release}“${genre ? `, Katalog-Genre: ${genre}` : ""}.`,
+  "discovery.reason.external": ({ release }) => `Aus dem abgerufenen externen Katalog, auf „${release}“.`,
+  "discovery.order": ({ path }) => `In dieser Reihenfolge anhören: ${path}.`,
+  "discovery.unavailable": "Ich konnte die Dienste zur Musikentdeckung nicht erreichen, daher gibt es diesmal keine Empfehlungen. Sende die Anfrage noch einmal, um es erneut zu versuchen.",
+
+  "citations.heading": "Öffentliche Musikquellen (getrennt von deinen persönlichen Hördaten):",
+  "citations.item": ({ label, url, storefront, date }) => `- [${label}](<${url}>) - ${storefront}-Store, abgerufen am ${date}.`,
+  "citations.scope": "Geltungsbereich: Diese öffentlichen Katalogseiten belegen weder persönliche Vorlieben noch einen vollständigen Hörverlauf noch die Verfügbarkeit auf anderen Plattformen.",
+  "web.sources.heading": ({ providers }) => `Öffentliche Webquellen (${providers})`,
+  "web.sources.headingUnnamed": "Öffentliche Webquellen",
+  "web.sources.published": ({ date }) => `Datum der Quelle: ${date}`,
+  "web.sources.retrieved": ({ date }) => `abgerufen: ${date}`,
+
+  "external.neighbors": ({ seed }) => seed ? `ListenBrainz-Hörer-Nachbarn von ${seed}` : "ListenBrainz-Hörer-Nachbarn",
+  "external.listenbrainz": ({ neighbor, date }) => `${neighbor} (Wikidata-Identität, CC0, abgerufen am ${date}; das ist keine klangliche Ähnlichkeit)`,
+  "external.appleMusic": ({ date }) => `Titeltreffer bei Apple Music US (abgerufen am ${date})`,
+  "external.limit": "Ausgeschlossen ist nur, was in deiner importierten Bibliothek mit gleichem Titel und Künstler vorkommt; du hast diese Songs also nicht unbedingt noch nie gehört. Es sind Vorschläge zum Reinhören.",
+  "external.from": ({ parts, limit }) => `Aus ${parts.join(" und ")}. ${limit}`,
+
+  "failure.deviceList": ({ noMatch, names, code }) => `Der Gerätename ${noMatch ? "passte zu keinem Gerät" : "passte zu mehreren Geräten"}. Spotify zeigt gerade: ${names}. Sag „spiel es auf“ und dann den angezeigten Gerätenamen; der ausgewählte Song bleibt erhalten. Es wurde keine Wiedergabe-Anfrage gesendet. (${code})`,
+  "failure.networkRead": ({ notSent, code }) => `Ein Netzwerkfehler hat das Lesen des Geräte- und Wiedergabestatus von Spotify verhindert; die Vorbereitung wurde abgebrochen.${notSent ? " Die Wiedergabe-Anfrage wurde nicht gesendet." : ""} Prüfe die Verbindung zu Spotify und versuche es erneut. (${code})`,
+  "failure.readiness.spotify_device_selection_required": "Der ausgewählte Song bleibt erhalten, aber das Zielgerät steht noch nicht fest. Nenne das gewünschte Gerät; das vorherige Gerät wird nicht stattdessen verwendet.",
+  "failure.readiness.spotify_device_not_found": "Spotify sieht das Zielgerät nicht. Öffne Spotify darauf und bitte dann erneut um die Wiedergabe; es wurde kein anderes Gerät stattdessen verwendet.",
+  "failure.readiness.spotify_device_ambiguous": "Möglicherweise sind mehrere Spotify-Geräte verfügbar. Nenne den gewünschten Gerätenamen.",
+  "failure.readiness.spotify_device_restricted": "Das Zielgerät bestätigt keine Steuerung über die Spotify Web API. Wähle ein anderes verfügbares Gerät.",
+  "failure.readiness.spotify_device_changed": "Ein anderes Spotify-Gerät wurde aktiv. Wähle das gewünschte Gerät ausdrücklich; die Wiedergabe wurde nicht automatisch verschoben.",
+  "failure.readiness.spotify_device_state_unconfirmed": "Der Geräte- und Wiedergabestatus von Spotify ist unvollständig oder widersprüchlich. Prüfe das aktuelle Gerät in Spotify, bevor du es erneut versuchst.",
+  "failure.readiness.spotify_device_not_ready": "Das Zielgerät war innerhalb der Wartezeit nicht bereit. Öffne Spotify darauf und bitte dann erneut um denselben Song.",
+  "failure.readiness.spotify_playback_restricted": "Spotify erlaubt gerade nicht, die Wiedergabe fortzusetzen. Prüfe das Zielgerät.",
+  "failure.songNotSent": " Die Wiedergabe-Anfrage wurde nicht gesendet.",
+  "failure.preparationStopped": ({ evidence }) => `Die Prüfung des Wiedergabegeräts wurde nicht abgeschlossen (${evidence}); es wurde keine Wiedergabe-Anfrage gesendet. Prüfe den Gerätestatus in Spotify, bevor du es erneut versuchst.`,
+  "failure.queueRequestRequired": "Es wurden keine Songs zur Warteschlange hinzugefügt: Ich konnte diese Antwort keiner Anfrage für die Warteschlange zuordnen. Um fortzufahren, braucht es eine ausdrückliche Bitte, Musik zur Warteschlange hinzuzufügen.",
+  "failure.notSent": ({ code }) => `An Spotify wurde nichts gesendet: Ich konnte das keinem der gefundenen Songs zuordnen (${code}). Frag noch einmal mit Songtitel oder Künstler, dann suche ich erneut.`,
+  "failure.outcome.lookup": "Die Spotify-Suche wurde nicht abgeschlossen",
+  "failure.outcome.unknown": "Das Ergebnis der Spotify-Aktion ist unklar",
+  "failure.outcome.unconfirmed": "Die Spotify-Wiedergabeaktion wurde nicht bestätigt",
+  "failure.reason": ({ reason }) => `Spotify meldet: ${reason}.`,
+  "failure.reasonUnknown": "Die genaue Ursache ist nicht bestätigt.",
+  "failure.lookup": ({ outcome, evidence, reason }) => `${outcome} (${evidence}). ${reason} Es wurde keine Wiedergabe und nichts für die Warteschlange gesendet.`,
+  "failure.general": ({ targets, outcome, evidence, reason, playbackNotSent, recovered }) =>
+    `${targets ? `Ziel: ${targets}.\n` : ""}${outcome} (${evidence}). ${reason}${playbackNotSent ? " Die Wiedergabe-Anfrage wurde nicht gesendet." : ""} ${recovered ? "Eine begrenzte Gerätewiederherstellung ist beendet; es gab keinen weiteren Versuch." : "Die Aktion wurde nicht wiederholt."} Lies den Wiedergabestatus und die verfügbaren Geräte, um weiter einzugrenzen.`,
+
+  "queue.unverified": ({ one }) => `Spotify hat ${one ? "ihn" : "sie"} angenommen, aber ich konnte deine Warteschlange nicht lesen, um das zu prüfen.`,
+  "queue.confirmedPlaying": ({ one }) => one ? "Wiedergabe auf Spotify bestätigt." : "Auf Spotify bestätigt: Der erste läuft, die übrigen stehen in deiner Warteschlange.",
+  "queue.confirmed": ({ count }) => count === 1 ? "In deiner Spotify-Warteschlange bestätigt." : `In deiner Spotify-Warteschlange bestätigt: alle ${count}.`,
+  "queue.partlyVisible": ({ accepted, confirmed, truncated }) => `Spotify hat ${accepted} angenommen; ${confirmed} sind gerade in deiner Warteschlange zu sehen${truncated ? " (Spotify zeigt bei langen Warteschlangen nur einen Teil)" : ""}.`,
+  "queue.noPlayback": "Auf Spotify läuft gerade kein Song, der als Ausgangspunkt dienen kann; es wurde nichts hinzugefügt.",
+  "queue.noCandidates": "Nach dem Filtern blieben keine passenden Kandidaten übrig; es wurde nichts hinzugefügt.",
+  "queue.requested": ({ requested, accepted, shortfall }) => `${requested} angefragt; Spotify hat ${accepted} angenommen${shortfall ? `, ${shortfall} fehlen` : ""}.`,
+  "queue.similarSeed": ({ artist }) => `Künstler, die laut Hörerdaten ${artist} ähneln:`,
+  "queue.cancelled": "Nach dem Abbruch werden keine weiteren Songs hinzugefügt; angenommene Titel bleiben in der Warteschlange.",
+  "queue.stopped": ({ count, title, artist }) => `${count} zur Spotify-Warteschlange hinzugefügt, dann bei „${title}“ - ${artist} angehalten.`,
+  "queue.queued": ({ count }) => `${count} zur Spotify-Warteschlange hinzugefügt:`,
+  "queue.queuedSome": ({ count, unmatched }) => `${count} von ${count + unmatched} zur Spotify-Warteschlange hinzugefügt:`,
+  "queue.outcomeUnknown": "Spotify hat nicht bestätigt, ob der angehaltene Titel hinzugefügt wurde. Prüfe die Warteschlange, bevor du es erneut versuchst; dieser Schreibvorgang wurde nicht wiederholt.",
+  "queue.started": ({ title, device, more }) => `Es lief nichts, also habe ich „${title}“${device ? ` auf ${device}` : ""} gestartet${more ? " und den Rest dahinter eingereiht" : ""}.`,
+  "queue.unmatchedHeading": "Auf Spotify nicht gefunden:",
+  "queue.skippedDuplicates": ({ count }) => `${count} doppelte Titel übersprungen.`,
+  "queue.skippedUncertain": ({ count }) => `${count} Titel mit unklarem früherem Ergebnis übersprungen, um Doppelungen zu vermeiden; prüfe die Spotify-Warteschlange.`,
+  "queue.skippedAvoided": ({ count }) => `${count} Titel übersprungen, die du vermeiden wolltest.`,
+  "queue.skippedKnown": ({ count }) => `${count} Titel aus deinem Hörverlauf übersprungen, wie gewünscht.`,
+  "queue.observationTruncated": "Doppelungen wurden nur im begrenzten Ausschnitt der Warteschlange geprüft, den Spotify liefert; nicht sichtbare Einträge können noch doppelt sein.",
+  "queue.notAddedHeading": "Nicht hinzugefügt:",
+  "queue.earlierReceipt": "Das ist das Ergebnis der früheren Warteschlangen-Aktion; diese Klarstellung hat die Songs nicht erneut hinzugefügt.",
+
+  "playlist.partialUnknown": ({ name }) => `Spotify hat die private Playlist „${name}“ erstellt, aber das Hinzufügen der Titel wurde nicht bestätigt. Prüfe sie, bevor du entscheidest, ob du es erneut versuchst.`,
+  "playlist.partialEmpty": ({ name }) => `Spotify hat die private Playlist „${name}“ erstellt, aber keine Titel hinzugefügt. Die leere Playlist existiert jetzt; prüfe sie, bevor du entscheidest, ob du es erneut versuchst.`,
+  "playlist.saved": ({ name, count }) => `Als private Spotify-Playlist „${name}“ gespeichert (${count} Titel).`,
+
+  "action.playback.resume": "Wiedergabe-Anfrage",
+  "action.playback.pause": "Pause-Anfrage",
+  "action.playback.next": "Anfrage für den nächsten Titel",
+  "action.playback.previous": "Anfrage für den vorherigen Titel",
+  "action.playback.volume.set": "Lautstärkeänderung",
+  "action.playback.seek": "Änderung der Wiedergabeposition",
+  "action.playback.shuffle.set": "Zufallswiedergabe-Einstellung",
+  "action.playback.repeat.set": "Wiederholungs-Einstellung",
+  "action.playback.transfer": "Gerätewechsel",
+  "action.playback.queue.add": "Hinzufügen zur Warteschlange",
+  "action.library.remove": "Entfernen aus der Bibliothek",
+  "action.library.save": "Speichern in der Bibliothek",
+  "action.playlist.write": "Erstellen der Playlist",
+  "action.playlist.edit": "Änderung der Playlist",
+  "action.playlist.rename": "Umbenennen der Playlist",
+  "action.playlist.unfollow": "Entfernen der Playlist aus der Bibliothek",
+  "action.playlist.remove_track": "Entfernen eines Titels aus der Playlist",
+  "action.other": "gewünschte Änderung",
+  "write.unknown": ({ action, target }) => `Spotify hat die Aktion „${action}“${target ? ` für „${target}“` : ""} nicht bestätigt. Prüfe den Status, bevor du entscheidest, ob du es erneut versuchst.`,
+  "write.unfollowed": ({ name }) => `„${name}“ wurde aus deiner Spotify-Bibliothek entfernt (nicht mehr gefolgt). Für andere Hörer kann die Playlist weiter bestehen; sie wurde nicht für alle gelöscht.`,
+  "write.renamed": ({ name }) => `Spotify hat das Umbenennen der Playlist in „${name}“ angenommen.`,
+  "write.trackRemoved": ({ name }) => `Spotify hat das Entfernen eines Titels aus „${name}“ angenommen.`,
+  "write.accepted": ({ action, count, targets }) => `Spotify hat die Aktion „${action}“ angenommen${count === null ? "" : ` (${count} Titel)`}${targets ? `: ${targets}` : ""}.`,
+
+  "plan.heading.private_library": ({ count }) => `Auswahl mit ${count} Titeln aus deiner Bibliothek:`,
+  "plan.heading.private_history": ({ count }) => `${count} Titel zum Wiederhören aus deinem Verlauf:`,
+  "plan.heading.external_catalog": ({ count }) => `${count} Songs:`,
+  "plan.heading.mixed": ({ count }) => `${count} Songs:`,
+  "plan.heading.timeCapsule": ({ count }) => `Zeitreise in ${count} Stationen durch deine Hörjahre:`,
+  "plan.heading.historicalReturn": ({ count }) => `${count} Titel, die nach langer Pause zurückkamen:`,
+  "plan.heading.backToBack": ({ count }) => `${count} Titel, die du direkt hintereinander gehört hast:`,
+  "plan.externalTrack": ({ line, release }) => `${line}, aus „${release}“`,
+  "plan.rationale": ({ text }) => `   Begründung der Auswahl: ${text}`,
+  "plan.ordering": ({ text }) => `Begründung der Reihenfolge: ${text}`,
+  "plan.notSaved": "Noch ist nichts gespeichert oder zur Warteschlange hinzugefügt.",
+  "plan.previewing": "Die 30-Sekunden-Vorschauen laufen in deinem Player; die vollständigen Songs gibt es bei Apple Music.",
+  "plan.pending": "Grenze: Diese Auswahl wartet nur in der laufenden Sitzung auf Bestätigung, wurde nicht in Spotify geschrieben und hat keine Auswirkungen nach außen.",
+  "plan.backToBackBoundary": "Grenze der Deutung: Direkt aufeinanderfolgende Wiedergaben belegen weder den Wiederholungsmodus noch bewusstes Wiederhören noch Gefallen.",
+  "plan.validationScope": "Umfang der Prüfung: Der lokale Planer prüft Titelidentität, Zugehörigkeit zu den Kandidaten, Anzahl und Reihenfolge; Begründungen und Passung zur Situation bleiben Einschätzungen des Modells auf Grundlage der verfügbaren Metadaten.",
+  "plan.unvalidated": "Ich konnte diese Auswahl nicht prüfen, deshalb gebe ich keine Titelliste aus, die nicht mit vertrauenswürdigen Kandidaten abgeglichen wurde. Grenze die Suche ein oder erweitere sie und versuche es erneut.",
+
+  "edit.previewHeading": ({ name, before, after }) => `Vorschau der Änderung an der privaten Spotify-Playlist „${name}“ (${before} -> ${after} Titel):`,
+  "edit.status.added": "neu",
+  "edit.status.moved": "verschoben",
+  "edit.status.retained": "bleibt",
+  "edit.removeHeading": "Entfernen:",
+  "edit.summary": ({ added, removed, moved, retained }) => `Zusammenfassung: ${added} hinzugefügt, ${removed} entfernt, ${moved} verschoben, ${retained} unverändert an ihrem Platz.`,
+  "edit.boundary": "Grenze: Spotify wurde noch nicht geändert. Bestätige in deiner nächsten Nachricht ausdrücklich, damit Moondog genau diese gespeicherte Version schreibt.",
+  "edit.updated": ({ name, before, after }) => `Die private Spotify-Playlist „${name}“ wurde genau nach der bestätigten Vorschau aktualisiert${before === null ? ` (jetzt ${after} Titel)` : ` (${before} -> ${after} Titel)`}.`,
+
+  "selection.note": ({ playlist, track }) => `\n\nFür weitere Änderungen ausgewählt: Playlist ${playlist}; Song ${track}.`,
+  "memory.spotifyExcluded": "\n\nSpotify-Ergebnisse kommen nicht ins allgemeine Gedächtnis; nur deine eigenen, überprüften Worte konnten gespeichert werden, alles andere wurde nicht gespeichert.",
+  "memory.notSaved": "\n\nDie Antwort ist fertig, aber die Erinnerung wurde nicht gespeichert.",
+  "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

@@ -0,0 +1,129 @@
+// Host-written conversation text. English is the source; keys are stable IDs.
+// Every value is a string or a function of named parameters.
+export default {
+  "discovery.reason.listenbrainz": ({ adjacent, seed, release }) => `ListenBrainz listening data connects ${adjacent} with ${seed}; from "${release}".`,
+  "discovery.reason.appleMusic": ({ queries, release, genre }) => `Apple Music catalog ${queries ? `match for ${queries}` : "candidate"}; from "${release}"${genre ? `, catalog genre: ${genre}` : ""}.`,
+  "discovery.reason.external": ({ release }) => `From the retrieved external catalog, on "${release}".`,
+  "discovery.order": ({ path }) => `Explore in this order: ${path}.`,
+  "discovery.unavailable": "I couldn't reach the music discovery services, so this request produced no recommendations. Please resend this request to try again.",
+
+  "citations.heading": "Public music sources (separate from personal listening evidence):",
+  "citations.item": ({ label, url, storefront, date }) => `- [${label}](<${url}>) - ${storefront} storefront, retrieved ${date}.`,
+  "citations.scope": "Scope: these public catalog pages do not establish personal preference, complete listening history, or cross-platform availability.",
+  "web.sources.heading": ({ providers }) => `Public web sources (${providers})`,
+  "web.sources.headingUnnamed": "Public web sources",
+  "web.sources.published": ({ date }) => `source date: ${date}`,
+  "web.sources.retrieved": ({ date }) => `retrieved: ${date}`,
+
+  "external.neighbors": ({ seed }) => seed ? `ListenBrainz listener-neighbors of ${seed}` : "ListenBrainz listener-neighbors",
+  "external.listenbrainz": ({ neighbor, date }) => `${neighbor} (Wikidata identity, CC0, retrieved ${date}; this is not audio similarity)`,
+  "external.appleMusic": ({ date }) => `Apple Music US title matches (retrieved ${date})`,
+  "external.limit": "A title-and-artist match in your imported library is the only thing excluded, so this does not mean you have never heard them. These are suggestions for listening.",
+  "external.from": ({ parts, limit }) => `From ${parts.join(", and ")}. ${limit}`,
+
+  "failure.deviceList": ({ noMatch, names, code }) => `The device name ${noMatch ? "did not match" : "matched several devices"}. Spotify currently lists: ${names}. Say “play it on” followed by the displayed device name; the selected song is retained. No song play request was sent. (${code})`,
+  "failure.networkRead": ({ notSent, code }) => `A network error prevented reading Spotify device/playback state; preparation stopped.${notSent ? " The song play request was not sent." : ""} Check the connection to Spotify and retry. (${code})`,
+  "failure.readiness.spotify_device_selection_required": "The selected song is retained, but the target device is not established. Name the intended device; the previous device will not be substituted.",
+  "failure.readiness.spotify_device_not_found": "Spotify cannot see the target device. Open Spotify on it, then request playback again; no other device was substituted.",
+  "failure.readiness.spotify_device_ambiguous": "Several Spotify devices may be available. Specify the intended device name.",
+  "failure.readiness.spotify_device_restricted": "The target device does not confirm Spotify Web API control. Choose another available device.",
+  "failure.readiness.spotify_device_changed": "Another Spotify device became active. Select the intended device explicitly; playback was not moved automatically.",
+  "failure.readiness.spotify_device_state_unconfirmed": "Spotify device/playback state is incomplete or inconsistent. Check the current device in Spotify before trying again.",
+  "failure.readiness.spotify_device_not_ready": "The target device did not become ready within the bounded wait. Open Spotify on it, then request the same song again.",
+  "failure.readiness.spotify_playback_restricted": "Spotify currently disallows resuming playback. Check the target device.",
+  "failure.songNotSent": " The song play request was not sent.",
+  "failure.preparationStopped": ({ evidence }) => `Playback device checks did not complete (${evidence}); no song play request was sent. Check Spotify device state before trying again.`,
+  "failure.queueRequestRequired": "No songs were queued: I could not connect this reply to a queue request. An explicit request to add music to the playback queue is needed to continue.",
+  "failure.notSent": ({ code }) => `Nothing was sent to Spotify: I couldn't match that to the songs I found (${code}). Ask again with the song or artist name, and I'll search again.`,
+  "failure.outcome.lookup": "The Spotify lookup did not complete",
+  "failure.outcome.unknown": "The Spotify action outcome is uncertain",
+  "failure.outcome.unconfirmed": "The Spotify playback action was not confirmed",
+  "failure.reason": ({ reason }) => `Spotify reported: ${reason}.`,
+  "failure.reasonUnknown": "The specific cause is unconfirmed.",
+  "failure.lookup": ({ outcome, evidence, reason }) => `${outcome} (${evidence}). ${reason} No play or queue action was sent.`,
+  "failure.general": ({ targets, outcome, evidence, reason, playbackNotSent, recovered }) =>
+    `${targets ? `Target: ${targets}.\n` : ""}${outcome} (${evidence}). ${reason}${playbackNotSent ? " The song play request was not sent." : ""} ${recovered ? "One bounded device recovery ended; no further retry was made." : "The action was not retried."} Read playback state and available devices to diagnose further.`,
+
+  "queue.unverified": ({ one }) => `Spotify accepted ${one ? "it" : "them"}, but I couldn't read your queue to double-check.`,
+  "queue.confirmedPlaying": ({ one }) => one ? "Confirmed playing on Spotify." : "Confirmed on Spotify: the first is playing and the rest are in your queue.",
+  "queue.confirmed": ({ count }) => count === 1 ? "Confirmed in your Spotify queue." : `Confirmed in your Spotify queue: all ${count}.`,
+  "queue.partlyVisible": ({ accepted, confirmed, truncated }) => `Spotify accepted ${accepted}; ${confirmed} show in your queue right now${truncated ? " (Spotify only shows part of a long queue)" : ""}.`,
+  "queue.noPlayback": "Spotify has no current track to use as a seed; nothing was queued.",
+  "queue.noCandidates": "No eligible candidates remained after filtering; nothing was queued.",
+  "queue.requested": ({ requested, accepted, shortfall }) => `Requested ${requested}; Spotify accepted ${accepted}${shortfall ? `, ${shortfall} short` : ""}.`,
+  "queue.similarSeed": ({ artist }) => `Listener-derived artist similarity from ${artist}:`,
+  "queue.cancelled": "Stopped queueing after cancellation; accepted tracks remain in the queue.",
+  "queue.stopped": ({ count, title, artist }) => `Queued ${count} on Spotify, then stopped at "${title}" - ${artist}.`,
+  "queue.queued": ({ count }) => `Queued ${count} on Spotify:`,
+  "queue.queuedSome": ({ count, unmatched }) => `Queued ${count} of ${count + unmatched} on Spotify:`,
+  "queue.outcomeUnknown": "Spotify did not confirm whether the stopped track was added. Check the queue before trying again; this write was not replayed.",
+  "queue.started": ({ title, device, more }) => `Nothing was playing, so I started "${title}"${device ? ` on ${device}` : ""}${more ? " and lined up the rest" : ""}.`,
+  "queue.unmatchedHeading": "Could not match on Spotify:",
+  "queue.skippedDuplicates": ({ count }) => `Skipped ${count} duplicate tracks.`,
+  "queue.skippedUncertain": ({ count }) => `Skipped ${count} tracks with earlier uncertain queue outcomes to avoid replay; check the Spotify queue.`,
+  "queue.skippedAvoided": ({ count }) => `Skipped ${count} avoided tracks.`,
+  "queue.skippedKnown": ({ count }) => `Skipped ${count} tracks matched in retained history, as requested.`,
+  "queue.observationTruncated": "Deduplication covers Spotify's bounded queue snapshot; unseen entries may still duplicate a selection.",
+  "queue.notAddedHeading": "Not added:",
+  "queue.earlierReceipt": "This is the earlier queue receipt; this clarification did not add the songs again.",
+
+  "playlist.partialUnknown": ({ name }) => `Spotify created the private playlist "${name}", but adding its tracks was not confirmed. Inspect it before deciding whether to retry.`,
+  "playlist.partialEmpty": ({ name }) => `Spotify created the private playlist "${name}", but did not add its tracks. The empty playlist now exists; inspect it before deciding whether to retry.`,
+  "playlist.saved": ({ name, count }) => `Saved as the private Spotify playlist "${name}" (${count} tracks).`,
+
+  "action.playback.resume": "playback request",
+  "action.playback.pause": "pause request",
+  "action.playback.next": "next-track request",
+  "action.playback.previous": "previous-track request",
+  "action.playback.volume.set": "volume change",
+  "action.playback.seek": "playback position change",
+  "action.playback.shuffle.set": "shuffle setting",
+  "action.playback.repeat.set": "repeat setting",
+  "action.playback.transfer": "device transfer",
+  "action.playback.queue.add": "queue addition",
+  "action.library.remove": "library removal",
+  "action.library.save": "library save",
+  "action.playlist.write": "playlist creation",
+  "action.playlist.edit": "playlist change",
+  "action.playlist.rename": "playlist rename",
+  "action.playlist.unfollow": "playlist removal from library",
+  "action.playlist.remove_track": "playlist track removal",
+  "action.other": "requested change",
+  "write.unknown": ({ action, target }) => `Spotify's ${action}${target ? ` for "${target}"` : ""} was not confirmed. Check its state before deciding whether to retry.`,
+  "write.unfollowed": ({ name }) => `Removed "${name}" from your Spotify library (unfollowed). The playlist may still exist for other listeners; it was not globally deleted.`,
+  "write.renamed": ({ name }) => `Spotify accepted the playlist rename to "${name}".`,
+  "write.trackRemoved": ({ name }) => `Spotify accepted removal of one track from "${name}".`,
+  "write.accepted": ({ action, count, targets }) => `Spotify accepted the ${action}${count === null ? "" : ` (${count} tracks)`}${targets ? `: ${targets}` : ""}.`,
+
+  "plan.heading.private_library": ({ count }) => `${count}-track plan from your library:`,
+  "plan.heading.private_history": ({ count }) => `${count}-track listen-again plan from your private history:`,
+  "plan.heading.external_catalog": ({ count }) => `${count} songs:`,
+  "plan.heading.mixed": ({ count }) => `${count} songs:`,
+  "plan.heading.timeCapsule": ({ count }) => `${count}-stop Listening Time Machine across your years:`,
+  "plan.heading.historicalReturn": ({ count }) => `${count}-track return path from your private history:`,
+  "plan.heading.backToBack": ({ count }) => `${count}-track played-back-to-back path from your private history:`,
+  "plan.externalTrack": ({ line, release }) => `${line}, from "${release}"`,
+  "plan.rationale": ({ text }) => `   Curatorial rationale: ${text}`,
+  "plan.ordering": ({ text }) => `Ordering rationale: ${text}`,
+  "plan.notSaved": "Nothing has been saved or queued yet.",
+  "plan.previewing": "The 30-second previews are playing in your player; the full songs are on Apple Music.",
+  "plan.pending": "Boundary: this plan is pending only in the current process, has not been written to Spotify, and has no external effects.",
+  "plan.backToBackBoundary": "Interpretation boundary: adjacent retained playback events do not prove repeat mode, intentional replay, or liking.",
+  "plan.validationScope": "Validation scope: the local planner validates track identity, candidate-set membership, count, and output order; curatorial reasons and situational fit remain model judgments based on available metadata.",
+  "plan.unvalidated": "I could not validate this playlist plan, so I will not return a track list that was not checked against trusted candidates. Please refine or broaden the search and try again.",
+
+  "edit.previewHeading": ({ name, before, after }) => `Spotify private playlist "${name}" edit preview (${before} -> ${after} tracks):`,
+  "edit.status.added": "add",
+  "edit.status.moved": "move",
+  "edit.status.retained": "keep",
+  "edit.removeHeading": "Remove:",
+  "edit.summary": ({ added, removed, moved, retained }) => `Change summary: ${added} added, ${removed} removed, ${moved} moved, ${retained} retained in place.`,
+  "edit.boundary": "Boundary: Spotify has not changed. Explicitly confirm in your next message before Moondog writes this exact host-retained version.",
+  "edit.updated": ({ name, before, after }) => `Updated the private Spotify playlist "${name}" from the exact confirmed preview${before === null ? ` (${after} tracks now)` : ` (${before} -> ${after} tracks)`}.`,
+
+  "selection.note": ({ playlist, track }) => `\n\nSelected for follow-up edits: playlist ${playlist}; song ${track}.`,
+  "memory.spotifyExcluded": "\n\nSpotify results are excluded from generic memory; only verified user quotes were eligible, and other claims were not saved.",
+  "memory.notSaved": "\n\nThe response completed, but the memory was not saved.",
+  "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

@@ -0,0 +1,128 @@
+// Español neutro, tuteo. Keys match messages/en.mjs; a missing key falls back to English.
+export default {
+  "discovery.reason.listenbrainz": ({ adjacent, seed, release }) => `Los datos de escucha de ListenBrainz relacionan a ${adjacent} con ${seed}; del álbum "${release}".`,
+  "discovery.reason.appleMusic": ({ queries, release, genre }) => `${queries ? `Coincidencia del catálogo de Apple Music para ${queries}` : "Candidato del catálogo de Apple Music"}; del álbum "${release}"${genre ? `, género en el catálogo: ${genre}` : ""}.`,
+  "discovery.reason.external": ({ release }) => `Del catálogo externo consultado, en "${release}".`,
+  "discovery.order": ({ path }) => `Escúchalas en este orden: ${path}.`,
+  "discovery.unavailable": "No pude conectar con los servicios de descubrimiento musical, así que esta petición no dio recomendaciones. Vuelve a enviarla para intentarlo de nuevo.",
+
+  "citations.heading": "Fuentes musicales públicas (aparte de tu historial de escucha personal):",
+  "citations.item": ({ label, url, storefront, date }) => `- [${label}](<${url}>) - tienda ${storefront}, consultada el ${date}.`,
+  "citations.scope": "Alcance: estas páginas públicas del catálogo no demuestran tus gustos personales, tu historial completo ni la disponibilidad en otras plataformas.",
+  "web.sources.heading": ({ providers }) => `Fuentes web públicas (${providers})`,
+  "web.sources.headingUnnamed": "Fuentes web públicas",
+  "web.sources.published": ({ date }) => `fecha de la fuente: ${date}`,
+  "web.sources.retrieved": ({ date }) => `consultado: ${date}`,
+
+  "external.neighbors": ({ seed }) => seed ? `oyentes afines a ${seed} en ListenBrainz` : "oyentes afines en ListenBrainz",
+  "external.listenbrainz": ({ neighbor, date }) => `${neighbor} (identidad de Wikidata, CC0, consultado el ${date}; esto no es similitud de sonido)`,
+  "external.appleMusic": ({ date }) => `coincidencias de título en Apple Music US (consultado el ${date})`,
+  "external.limit": "Solo se excluye lo que coincide en título y artista con tu biblioteca importada, así que no significa que nunca las hayas escuchado. Son sugerencias para escuchar.",
+  "external.from": ({ parts, limit }) => `A partir de ${parts.join(" y ")}. ${limit}`,
+
+  "failure.deviceList": ({ noMatch, names, code }) => `El nombre del dispositivo ${noMatch ? "no coincide con ninguno" : "coincide con varios dispositivos"}. Spotify muestra ahora: ${names}. Di "ponla en" seguido del nombre que aparece; la canción elegida se conserva. No se envió ninguna petición de reproducción. (${code})`,
+  "failure.networkRead": ({ notSent, code }) => `Un error de red impidió leer el estado de los dispositivos o de la reproducción de Spotify; la preparación se detuvo.${notSent ? " No se envió la petición de reproducción." : ""} Revisa la conexión con Spotify y vuelve a intentarlo. (${code})`,
+  "failure.readiness.spotify_device_selection_required": "La canción elegida se conserva, pero falta decidir el dispositivo. Di cuál quieres usar; no se usará el anterior en su lugar.",
+  "failure.readiness.spotify_device_not_found": "Spotify no ve el dispositivo elegido. Abre Spotify en él y vuelve a pedir la canción; no se usó otro dispositivo en su lugar.",
+  "failure.readiness.spotify_device_ambiguous": "Puede haber varios dispositivos de Spotify disponibles. Di el nombre del que quieres usar.",
+  "failure.readiness.spotify_device_restricted": "El dispositivo elegido no confirma que se pueda controlar desde la API web de Spotify. Elige otro dispositivo disponible.",
+  "failure.readiness.spotify_device_changed": "Se activó otro dispositivo de Spotify. Elige el dispositivo que quieres; la reproducción no se movió automáticamente.",
+  "failure.readiness.spotify_device_state_unconfirmed": "El estado de los dispositivos o de la reproducción de Spotify está incompleto o no cuadra. Revisa el dispositivo actual en Spotify antes de volver a intentarlo.",
+  "failure.readiness.spotify_device_not_ready": "El dispositivo no estuvo listo dentro del tiempo de espera. Abre Spotify en él y vuelve a pedir la misma canción.",
+  "failure.readiness.spotify_playback_restricted": "Ahora mismo Spotify no permite reanudar la reproducción. Revisa el dispositivo.",
+  "failure.songNotSent": " No se envió la petición de reproducción.",
+  "failure.preparationStopped": ({ evidence }) => `Las comprobaciones del dispositivo no terminaron (${evidence}); no se envió ninguna petición de reproducción. Revisa el estado del dispositivo en Spotify antes de volver a intentarlo.`,
+  "failure.queueRequestRequired": "No se añadió ninguna canción: no pude relacionar esta respuesta con una petición para la cola. Para seguir, pide de forma explícita añadir música a la cola.",
+  "failure.notSent": ({ code }) => `No envié nada a Spotify: no pude relacionarlo con las canciones que encontré (${code}). Vuelve a pedirlo con el nombre de la canción o del artista y la busco de nuevo.`,
+  "failure.outcome.lookup": "La búsqueda en Spotify no terminó",
+  "failure.outcome.unknown": "No se sabe con certeza el resultado de la acción en Spotify",
+  "failure.outcome.unconfirmed": "Spotify no confirmó la acción de reproducción",
+  "failure.reason": ({ reason }) => `Spotify indicó: ${reason}.`,
+  "failure.reasonUnknown": "La causa concreta no está confirmada.",
+  "failure.lookup": ({ outcome, evidence, reason }) => `${outcome} (${evidence}). ${reason} No se envió ninguna acción de reproducción ni de cola.`,
+  "failure.general": ({ targets, outcome, evidence, reason, playbackNotSent, recovered }) =>
+    `${targets ? `Objetivo: ${targets}.\n` : ""}${outcome} (${evidence}). ${reason}${playbackNotSent ? " No se envió la petición de reproducción." : ""} ${recovered ? "Terminó un intento acotado de recuperar el dispositivo; no se volvió a intentar." : "La acción no se volvió a intentar."} Consulta el estado de la reproducción y los dispositivos disponibles para saber más.`,
+
+  "queue.unverified": ({ one }) => `Spotify ${one ? "la aceptó" : "las aceptó"}, pero no pude leer tu cola para comprobarlo.`,
+  "queue.confirmedPlaying": ({ one }) => one ? "Confirmado: está sonando en Spotify." : "Confirmado en Spotify: la primera está sonando y el resto están en tu cola.",
+  "queue.confirmed": ({ count }) => count === 1 ? "Confirmado en tu cola de Spotify." : `Confirmadas en tu cola de Spotify: las ${count}.`,
+  "queue.partlyVisible": ({ accepted, confirmed, truncated }) => `Spotify aceptó ${accepted}; ahora mismo se ven ${confirmed} en tu cola${truncated ? " (Spotify solo muestra parte de una cola larga)" : ""}.`,
+  "queue.noPlayback": "Spotify no tiene ninguna canción sonando que sirva de punto de partida; no se añadió nada.",
+  "queue.noCandidates": "Después de filtrar no quedó ninguna candidata; no se añadió nada.",
+  "queue.requested": ({ requested, accepted, shortfall }) => `Pediste ${requested}; Spotify aceptó ${accepted}${shortfall ? `, faltan ${shortfall}` : ""}.`,
+  "queue.similarSeed": ({ artist }) => `Artistas afines a ${artist} según otros oyentes:`,
+  "queue.cancelled": "Dejé de añadir canciones tras la cancelación; las que ya se aceptaron siguen en la cola.",
+  "queue.stopped": ({ count, title, artist }) => `Añadí ${count} a la cola de Spotify y me detuve en "${title}" - ${artist}.`,
+  "queue.queued": ({ count }) => `Añadí ${count} a la cola de Spotify:`,
+  "queue.queuedSome": ({ count, unmatched }) => `Añadí ${count} de ${count + unmatched} a la cola de Spotify:`,
+  "queue.outcomeUnknown": "Spotify no confirmó si se añadió la canción en la que me detuve. Revisa la cola antes de volver a intentarlo; no la reenvié.",
+  "queue.started": ({ title, device, more }) => `No sonaba nada, así que puse "${title}"${device ? ` en ${device}` : ""}${more ? " y dejé el resto en la cola" : ""}.`,
+  "queue.unmatchedHeading": "No encontradas en Spotify:",
+  "queue.skippedDuplicates": ({ count }) => `Omití ${count} canciones repetidas.`,
+  "queue.skippedUncertain": ({ count }) => `Omití ${count} canciones cuyo resultado anterior en la cola no estaba claro, para no repetirlas; revisa la cola de Spotify.`,
+  "queue.skippedAvoided": ({ count }) => `Omití ${count} canciones que marcaste para evitar.`,
+  "queue.skippedKnown": ({ count }) => `Omití ${count} canciones que ya aparecen en tu historial, como pediste.`,
+  "queue.observationTruncated": "La comprobación de repetidas solo cubre la parte de la cola que muestra Spotify; lo que no se ve podría repetir alguna.",
+  "queue.notAddedHeading": "Sin añadir:",
+  "queue.earlierReceipt": "Este es el resultado de la cola anterior; esta aclaración no volvió a añadir las canciones.",
+
+  "playlist.partialUnknown": ({ name }) => `Spotify creó la playlist privada "${name}", pero no confirmó que se añadieran las canciones. Revísala antes de decidir si lo intentas de nuevo.`,
+  "playlist.partialEmpty": ({ name }) => `Spotify creó la playlist privada "${name}", pero no añadió las canciones. La playlist vacía ya existe; revísala antes de decidir si lo intentas de nuevo.`,
+  "playlist.saved": ({ name, count }) => `Guardada como la playlist privada de Spotify "${name}" (${count} canciones).`,
+
+  "action.playback.resume": "la petición de reproducción",
+  "action.playback.pause": "la pausa",
+  "action.playback.next": "el salto a la siguiente",
+  "action.playback.previous": "la vuelta a la anterior",
+  "action.playback.volume.set": "el cambio de volumen",
+  "action.playback.seek": "el cambio de posición",
+  "action.playback.shuffle.set": "el ajuste de aleatorio",
+  "action.playback.repeat.set": "el ajuste de repetición",
+  "action.playback.transfer": "el cambio de dispositivo",
+  "action.playback.queue.add": "la adición a la cola",
+  "action.library.remove": "la eliminación de tu biblioteca",
+  "action.library.save": "el guardado en tu biblioteca",
+  "action.playlist.write": "la creación de la playlist",
+  "action.playlist.edit": "el cambio en la playlist",
+  "action.playlist.rename": "el cambio de nombre de la playlist",
+  "action.playlist.unfollow": "la eliminación de la playlist de tu biblioteca",
+  "action.playlist.remove_track": "la eliminación de una canción de la playlist",
+  "action.other": "el cambio pedido",
+  "write.unknown": ({ action, target }) => `Spotify no confirmó ${action}${target ? ` para "${target}"` : ""}. Revisa su estado antes de decidir si lo intentas de nuevo.`,
+  "write.unfollowed": ({ name }) => `Quité "${name}" de tu biblioteca de Spotify (dejaste de seguirla). La playlist puede seguir existiendo para otros oyentes; no se borró.`,
+  "write.renamed": ({ name }) => `Spotify aceptó el nuevo nombre de la playlist: "${name}".`,
+  "write.trackRemoved": ({ name }) => `Spotify aceptó quitar una canción de "${name}".`,
+  "write.accepted": ({ action, count, targets }) => `Spotify aceptó ${action}${count === null ? "" : ` (${count} canciones)`}${targets ? `: ${targets}` : ""}.`,
+
+  "plan.heading.private_library": ({ count }) => `Plan de ${count} canciones de tu biblioteca:`,
+  "plan.heading.private_history": ({ count }) => `Plan de ${count} canciones de tu historial para volver a escuchar:`,
+  "plan.heading.external_catalog": ({ count }) => `${count} canciones:`,
+  "plan.heading.mixed": ({ count }) => `${count} canciones:`,
+  "plan.heading.timeCapsule": ({ count }) => `Máquina del tiempo de ${count} paradas por tus años de escucha:`,
+  "plan.heading.historicalReturn": ({ count }) => `${count} canciones de tu historial que volvieron tras una larga pausa:`,
+  "plan.heading.backToBack": ({ count }) => `${count} canciones de tu historial que escuchaste seguidas:`,
+  "plan.externalTrack": ({ line, release }) => `${line}, del álbum "${release}"`,
+  "plan.rationale": ({ text }) => `   Por qué está: ${text}`,
+  "plan.ordering": ({ text }) => `Por qué este orden: ${text}`,
+  "plan.notSaved": "Todavía no se ha guardado ni añadido nada a la cola.",
+  "plan.previewing": "Los avances de 30 segundos suenan en tu reproductor; las canciones completas están en Apple Music.",
+  "plan.pending": "Límite: este plan solo está pendiente en esta sesión, no se ha escrito en Spotify y no tiene efectos externos.",
+  "plan.backToBackBoundary": "Cómo leerlo: que dos reproducciones guardadas vayan seguidas no demuestra que usaras la repetición, que la volvieras a poner a propósito ni que te guste.",
+  "plan.validationScope": "Qué se comprobó: el planificador local verifica la identidad de cada canción, que pertenezca a las candidatas, la cantidad y el orden; los motivos y el encaje con el momento siguen siendo juicios del modelo a partir de los metadatos disponibles.",
+  "plan.unvalidated": "No pude validar este plan, así que no te daré una lista que no se haya comprobado contra candidatas fiables. Afina o amplía la búsqueda y vuelve a intentarlo.",
+
+  "edit.previewHeading": ({ name, before, after }) => `Vista previa de cambios en la playlist privada de Spotify "${name}" (${before} -> ${after} canciones):`,
+  "edit.status.added": "añadir",
+  "edit.status.moved": "mover",
+  "edit.status.retained": "mantener",
+  "edit.removeHeading": "Quitar:",
+  "edit.summary": ({ added, removed, moved, retained }) => `Resumen: ${added} añadidas, ${removed} quitadas, ${moved} movidas y ${retained} sin cambios.`,
+  "edit.boundary": "Límite: Spotify no ha cambiado. Confírmalo de forma explícita en tu próximo mensaje para que Moondog escriba exactamente esta versión.",
+  "edit.updated": ({ name, before, after }) => `Actualicé la playlist privada de Spotify "${name}" con la vista previa que confirmaste${before === null ? ` (ahora tiene ${after} canciones)` : ` (${before} -> ${after} canciones)`}.`,
+
+  "selection.note": ({ playlist, track }) => `\n\nSeleccionado para próximos cambios: playlist ${playlist}; canción ${track}.`,
+  "memory.spotifyExcluded": "\n\nLos resultados de Spotify no se guardan en la memoria general; solo se podían guardar citas tuyas verificables, y lo demás no se guardó.",
+  "memory.notSaved": "\n\nLa respuesta terminó, pero no se pudo guardar la memoria.",
+  "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

@@ -0,0 +1,128 @@
+// Français. Keys match messages/en.mjs; a missing key falls back to English.
+export default {
+  "discovery.reason.listenbrainz": ({ adjacent, seed, release }) => `Les données d'écoute de ListenBrainz relient ${adjacent} à ${seed} ; extrait de « ${release} ».`,
+  "discovery.reason.appleMusic": ({ queries, release, genre }) => `Catalogue Apple Music : ${queries ? `correspond à ${queries}` : "candidat"} ; extrait de « ${release} »${genre ? `, genre du catalogue : ${genre}` : ""}.`,
+  "discovery.reason.external": ({ release }) => `Tiré du catalogue externe consulté, sur « ${release} ».`,
+  "discovery.order": ({ path }) => `À écouter dans cet ordre : ${path}.`,
+  "discovery.unavailable": "Je n'ai pas pu joindre les services de découverte musicale, donc cette demande n'a produit aucune recommandation. Renvoyez la demande pour réessayer.",
+
+  "citations.heading": "Sources musicales publiques (distinctes de vos données d'écoute personnelles) :",
+  "citations.item": ({ label, url, storefront, date }) => `- [${label}](<${url}>) - boutique ${storefront}, consultée le ${date}.`,
+  "citations.scope": "Portée : ces pages de catalogue publiques ne prouvent ni une préférence personnelle, ni un historique d'écoute complet, ni la disponibilité sur d'autres plateformes.",
+  "web.sources.heading": ({ providers }) => `Sources web publiques (${providers})`,
+  "web.sources.headingUnnamed": "Sources web publiques",
+  "web.sources.published": ({ date }) => `date de la source : ${date}`,
+  "web.sources.retrieved": ({ date }) => `consulté le ${date}`,
+
+  "external.neighbors": ({ seed }) => seed ? `voisins d'écoute ListenBrainz de ${seed}` : "voisins d'écoute ListenBrainz",
+  "external.listenbrainz": ({ neighbor, date }) => `${neighbor} (identité Wikidata, CC0, consultée le ${date} ; ce n'est pas une similarité audio)`,
+  "external.appleMusic": ({ date }) => `correspondances de titres Apple Music US (consultées le ${date})`,
+  "external.limit": "Seuls les titres déjà présents dans votre bibliothèque importée, avec le même artiste, sont exclus : cela ne veut pas dire que vous ne les avez jamais entendus. Ce sont des suggestions d'écoute.",
+  "external.from": ({ parts, limit }) => `D'après ${parts.join(", et ")}. ${limit}`,
+
+  "failure.deviceList": ({ noMatch, names, code }) => `Le nom d'appareil ${noMatch ? "ne correspond à aucun appareil" : "correspond à plusieurs appareils"}. Spotify affiche actuellement : ${names}. Dites « joue-le sur » suivi du nom affiché ; le morceau choisi est conservé. Aucune demande de lecture n'a été envoyée. (${code})`,
+  "failure.networkRead": ({ notSent, code }) => `Une erreur réseau a empêché de lire l'état des appareils et de la lecture Spotify ; la préparation s'est arrêtée.${notSent ? " La demande de lecture n'a pas été envoyée." : ""} Vérifiez la connexion à Spotify et réessayez. (${code})`,
+  "failure.readiness.spotify_device_selection_required": "Le morceau choisi est conservé, mais l'appareil cible n'est pas déterminé. Indiquez l'appareil voulu ; l'appareil précédent ne sera pas utilisé à sa place.",
+  "failure.readiness.spotify_device_not_found": "Spotify ne voit pas l'appareil cible. Ouvrez Spotify dessus, puis redemandez la lecture ; aucun autre appareil n'a été utilisé à sa place.",
+  "failure.readiness.spotify_device_ambiguous": "Plusieurs appareils Spotify sont peut-être disponibles. Précisez le nom de l'appareil voulu.",
+  "failure.readiness.spotify_device_restricted": "L'appareil cible ne confirme pas le contrôle par l'API Web de Spotify. Choisissez un autre appareil disponible.",
+  "failure.readiness.spotify_device_changed": "Un autre appareil Spotify est devenu actif. Choisissez explicitement l'appareil voulu ; la lecture n'a pas été déplacée automatiquement.",
+  "failure.readiness.spotify_device_state_unconfirmed": "L'état des appareils et de la lecture Spotify est incomplet ou incohérent. Vérifiez l'appareil actuel dans Spotify avant de réessayer.",
+  "failure.readiness.spotify_device_not_ready": "L'appareil cible n'a pas été prêt dans le délai prévu. Ouvrez Spotify dessus, puis redemandez le même morceau.",
+  "failure.readiness.spotify_playback_restricted": "Spotify n'autorise pas la reprise de la lecture pour le moment. Vérifiez l'appareil cible.",
+  "failure.songNotSent": " La demande de lecture n'a pas été envoyée.",
+  "failure.preparationStopped": ({ evidence }) => `Les vérifications de l'appareil de lecture n'ont pas abouti (${evidence}) ; aucune demande de lecture n'a été envoyée. Vérifiez l'état de l'appareil Spotify avant de réessayer.`,
+  "failure.queueRequestRequired": "Aucun morceau n'a été ajouté à la file d'attente : je n'ai pas pu relier cette réponse à une demande d'ajout. Il faut une demande explicite d'ajouter de la musique à la file d'attente pour continuer.",
+  "failure.notSent": ({ code }) => `Rien n'a été envoyé à Spotify : je n'ai pas pu relier cela aux morceaux trouvés (${code}). Redemandez avec le titre ou l'artiste, et je chercherai à nouveau.`,
+  "failure.outcome.lookup": "La recherche Spotify n'a pas abouti",
+  "failure.outcome.unknown": "Le résultat de l'action Spotify est incertain",
+  "failure.outcome.unconfirmed": "L'action de lecture Spotify n'a pas été confirmée",
+  "failure.reason": ({ reason }) => `Motif indiqué par Spotify : ${reason}.`,
+  "failure.reasonUnknown": "La cause précise n'est pas confirmée.",
+  "failure.lookup": ({ outcome, evidence, reason }) => `${outcome} (${evidence}). ${reason} Aucune lecture ni aucun ajout à la file d'attente n'a été envoyé.`,
+  "failure.general": ({ targets, outcome, evidence, reason, playbackNotSent, recovered }) =>
+    `${targets ? `Cible : ${targets}.\n` : ""}${outcome} (${evidence}). ${reason}${playbackNotSent ? " La demande de lecture n'a pas été envoyée." : ""} ${recovered ? "Une récupération limitée de l'appareil s'est terminée ; aucune autre tentative n'a été faite." : "L'action n'a pas été retentée."} Lisez l'état de la lecture et les appareils disponibles pour aller plus loin.`,
+
+  "queue.unverified": ({ one }) => `Spotify ${one ? "l'a accepté" : "les a acceptés"}, mais je n'ai pas pu lire votre file d'attente pour vérifier.`,
+  "queue.confirmedPlaying": ({ one }) => one ? "Lecture confirmée sur Spotify." : "Confirmé sur Spotify : le premier est en lecture et les autres sont dans votre file d'attente.",
+  "queue.confirmed": ({ count }) => count === 1 ? "Confirmé dans votre file d'attente Spotify." : `Confirmé dans votre file d'attente Spotify : les ${count}.`,
+  "queue.partlyVisible": ({ accepted, confirmed, truncated }) => `Spotify en a accepté ${accepted} ; ${confirmed} apparaissent dans votre file d'attente pour l'instant${truncated ? " (Spotify n'affiche qu'une partie d'une longue file)" : ""}.`,
+  "queue.noPlayback": "Spotify n'a aucun morceau en cours à prendre comme point de départ ; rien n'a été ajouté.",
+  "queue.noCandidates": "Aucun candidat ne restait après le filtrage ; rien n'a été ajouté.",
+  "queue.requested": ({ requested, accepted, shortfall }) => `${requested} demandés ; Spotify en a accepté ${accepted}${shortfall ? `, il en manque ${shortfall}` : ""}.`,
+  "queue.similarSeed": ({ artist }) => `Artistes proches de ${artist}, d'après les auditeurs :`,
+  "queue.cancelled": "Ajout arrêté après l'annulation ; les morceaux acceptés restent dans la file d'attente.",
+  "queue.stopped": ({ count, title, artist }) => `${count} ajoutés à la file d'attente Spotify, puis arrêt à « ${title} » - ${artist}.`,
+  "queue.queued": ({ count }) => `${count} ajoutés à la file d'attente Spotify :`,
+  "queue.queuedSome": ({ count, unmatched }) => `${count} sur ${count + unmatched} ajoutés à la file d'attente Spotify :`,
+  "queue.outcomeUnknown": "Spotify n'a pas confirmé si le morceau interrompu a été ajouté. Vérifiez la file d'attente avant de réessayer ; cette écriture n'a pas été renvoyée.",
+  "queue.started": ({ title, device, more }) => `Rien ne jouait, alors j'ai lancé « ${title} »${device ? ` sur ${device}` : ""}${more ? " et mis la suite dans la file" : ""}.`,
+  "queue.unmatchedHeading": "Introuvables sur Spotify :",
+  "queue.skippedDuplicates": ({ count }) => `${count} doublons ignorés.`,
+  "queue.skippedUncertain": ({ count }) => `${count} morceaux ignorés pour éviter un doublon, car leur ajout précédent est incertain ; vérifiez la file d'attente Spotify.`,
+  "queue.skippedAvoided": ({ count }) => `${count} morceaux à éviter ignorés.`,
+  "queue.skippedKnown": ({ count }) => `${count} morceaux déjà présents dans votre historique ignorés, comme demandé.`,
+  "queue.observationTruncated": "Le dédoublonnage ne couvre que l'extrait limité de la file que Spotify renvoie ; des entrées non visibles peuvent encore faire doublon.",
+  "queue.notAddedHeading": "Non ajoutés :",
+  "queue.earlierReceipt": "Voici le reçu de l'ajout précédent ; cette précision n'a pas ajouté les morceaux une seconde fois.",
+
+  "playlist.partialUnknown": ({ name }) => `Spotify a créé la playlist privée « ${name} », mais l'ajout de ses morceaux n'a pas été confirmé. Vérifiez-la avant de décider de réessayer.`,
+  "playlist.partialEmpty": ({ name }) => `Spotify a créé la playlist privée « ${name} », mais n'a pas ajouté ses morceaux. La playlist vide existe désormais ; vérifiez-la avant de décider de réessayer.`,
+  "playlist.saved": ({ name, count }) => `Enregistré comme playlist Spotify privée « ${name} » (${count} morceaux).`,
+
+  "action.playback.resume": "demande de lecture",
+  "action.playback.pause": "demande de pause",
+  "action.playback.next": "demande de morceau suivant",
+  "action.playback.previous": "demande de morceau précédent",
+  "action.playback.volume.set": "changement de volume",
+  "action.playback.seek": "changement de position de lecture",
+  "action.playback.shuffle.set": "réglage de la lecture aléatoire",
+  "action.playback.repeat.set": "réglage de la répétition",
+  "action.playback.transfer": "changement d'appareil",
+  "action.playback.queue.add": "ajout à la file d'attente",
+  "action.library.remove": "retrait de la bibliothèque",
+  "action.library.save": "ajout à la bibliothèque",
+  "action.playlist.write": "création de playlist",
+  "action.playlist.edit": "modification de playlist",
+  "action.playlist.rename": "renommage de playlist",
+  "action.playlist.unfollow": "retrait de la playlist de la bibliothèque",
+  "action.playlist.remove_track": "retrait d'un morceau de la playlist",
+  "action.other": "modification demandée",
+  "write.unknown": ({ action, target }) => `Spotify n'a pas confirmé l'opération « ${action} »${target ? ` pour « ${target} »` : ""}. Vérifiez son état avant de décider de réessayer.`,
+  "write.unfollowed": ({ name }) => `« ${name} » a été retirée de votre bibliothèque Spotify (vous ne la suivez plus). La playlist peut encore exister pour d'autres auditeurs ; elle n'a pas été supprimée pour tous.`,
+  "write.renamed": ({ name }) => `Spotify a accepté de renommer la playlist en « ${name} ».`,
+  "write.trackRemoved": ({ name }) => `Spotify a accepté le retrait d'un morceau de « ${name} ».`,
+  "write.accepted": ({ action, count, targets }) => `Spotify a accepté l'opération « ${action} »${count === null ? "" : ` (${count} morceaux)`}${targets ? ` : ${targets}` : ""}.`,
+
+  "plan.heading.private_library": ({ count }) => `Sélection de ${count} morceaux tirée de votre bibliothèque :`,
+  "plan.heading.private_history": ({ count }) => `${count} morceaux à réécouter, tirés de votre historique :`,
+  "plan.heading.external_catalog": ({ count }) => `${count} morceaux :`,
+  "plan.heading.mixed": ({ count }) => `${count} morceaux :`,
+  "plan.heading.timeCapsule": ({ count }) => `Machine à remonter le temps en ${count} étapes à travers vos années d'écoute :`,
+  "plan.heading.historicalReturn": ({ count }) => `${count} morceaux revenus après une longue absence :`,
+  "plan.heading.backToBack": ({ count }) => `${count} morceaux que vous avez écoutés à la suite :`,
+  "plan.externalTrack": ({ line, release }) => `${line}, extrait de « ${release} »`,
+  "plan.rationale": ({ text }) => `   Raison du choix : ${text}`,
+  "plan.ordering": ({ text }) => `Raison de l'ordre : ${text}`,
+  "plan.notSaved": "Rien n'a encore été enregistré ni ajouté à la file d'attente.",
+  "plan.previewing": "Les extraits de 30 secondes jouent dans votre lecteur ; les morceaux complets sont sur Apple Music.",
+  "plan.pending": "Limite : cette sélection n'attend une confirmation que dans la session en cours ; elle n'a pas été écrite sur Spotify et n'a aucun effet extérieur.",
+  "plan.backToBackBoundary": "Limite d'interprétation : des écoutes enregistrées à la suite ne prouvent ni le mode répétition, ni une réécoute voulue, ni un goût pour le morceau.",
+  "plan.validationScope": "Portée de la vérification : le planificateur local vérifie l'identité des morceaux, leur appartenance aux candidats, leur nombre et leur ordre ; les raisons du choix et l'adéquation à la situation restent des jugements du modèle, fondés sur les métadonnées disponibles.",
+  "plan.unvalidated": "Je n'ai pas pu vérifier cette sélection, donc je ne renverrai pas une liste de morceaux non comparée à des candidats fiables. Précisez ou élargissez la recherche, puis réessayez.",
+
+  "edit.previewHeading": ({ name, before, after }) => `Aperçu de la modification de la playlist Spotify privée « ${name} » (${before} -> ${after} morceaux) :`,
+  "edit.status.added": "ajout",
+  "edit.status.moved": "déplacé",
+  "edit.status.retained": "conservé",
+  "edit.removeHeading": "À retirer :",
+  "edit.summary": ({ added, removed, moved, retained }) => `Résumé des changements : ${added} ajoutés, ${removed} retirés, ${moved} déplacés, ${retained} conservés à leur place.`,
+  "edit.boundary": "Limite : Spotify n'a pas changé. Confirmez explicitement dans votre prochain message pour que Moondog écrive exactement cette version conservée.",
+  "edit.updated": ({ name, before, after }) => `Playlist Spotify privée « ${name} » mise à jour d'après l'aperçu confirmé${before === null ? ` (${after} morceaux maintenant)` : ` (${before} -> ${after} morceaux)`}.`,
+
+  "selection.note": ({ playlist, track }) => `\n\nSélection pour les prochaines modifications : playlist ${playlist} ; morceau ${track}.`,
+  "memory.spotifyExcluded": "\n\nLes résultats Spotify sont exclus de la mémoire générale ; seules vos propres paroles vérifiées pouvaient être retenues, et le reste n'a pas été enregistré.",
+  "memory.notSaved": "\n\nLa réponse est terminée, mais la mémoire n'a pas été enregistrée.",
+  "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.",
+};