@audiofool/moondog 0.1.0 → 0.2.0-beta.3

package/src/i18n/index.mjs

@@ -0,0 +1,285 @@
+import de from "./messages/de.mjs";
+import en from "./messages/en.mjs";
+import es from "./messages/es.mjs";
+import fr from "./messages/fr.mjs";
+import it from "./messages/it.mjs";
+import ja from "./messages/ja.mjs";
+import ko from "./messages/ko.mjs";
+import pt from "./messages/pt.mjs";
+import zhHant from "./messages/zh-Hant.mjs";
+import zh from "./messages/zh.mjs";
+import esScreen from "./screen/es.mjs";
+import jaScreen from "./screen/ja.mjs";
+import ptScreen from "./screen/pt.mjs";
+import zhScreen from "./screen/zh.mjs";
+
+// English is the source language; every other catalog falls back to it.
+export const DEFAULT_LOCALE = "en";
+export const LOCALES = Object.freeze({
+  en: Object.freeze({ name: "English", nativeName: "English" }),
+  es: Object.freeze({ name: "Spanish", nativeName: "Español" }),
+  ja: Object.freeze({ name: "Japanese", nativeName: "日本語" }),
+  pt: Object.freeze({ name: "Brazilian Portuguese", nativeName: "Português (Brasil)" }),
+  zh: Object.freeze({ name: "Simplified Chinese", nativeName: "简体中文" }),
+  "zh-Hant": Object.freeze({ name: "Traditional Chinese", nativeName: "繁體中文" }),
+  ko: Object.freeze({ name: "Korean", nativeName: "한국어" }),
+  fr: Object.freeze({ name: "French", nativeName: "Français" }),
+  de: Object.freeze({ name: "German", nativeName: "Deutsch" }),
+  it: Object.freeze({ name: "Italian", nativeName: "Italiano" }),
+});
+const CATALOGS = { en, es, ja, pt, zh, "zh-Hant": zhHant, ko, fr, de, it };
+// Screen text is keyed by its English sentence, gettext style; English needs no file.
+// Replies come in every locale; the terminal's own screen text exists in these.
+const SCREEN = { en: {}, es: esScreen, ja: jaScreen, pt: ptScreen, zh: zhScreen };
+export const SCREEN_LOCALES = Object.freeze(Object.keys(SCREEN));
+// Traditional Chinese falls back to Simplified before English.
+const PARENT = { "zh-Hant": "zh" };
+
+/** The Intl tag for numbers and plurals: Simplified is mainland, Traditional is Taiwan, Portuguese is Brazilian. */
+export function intlLocale(code) {
+  return { zh: "zh-CN", "zh-Hant": "zh-TW", pt: "pt-BR" }[code] ?? code;
+}
+
+const TRADITIONAL_CHINESE = new Set(["hant", "tw", "hk", "mo"]);
+
+/** "es_ES.UTF-8", "es-MX" and "ES" all mean Spanish; "zh_TW" and "zh-Hant" mean Traditional Chinese; anything unsupported is null. */
+export function normalizeLocale(value) {
+  if (typeof value !== "string") return null;
+  const [language, ...rest] = value.trim().toLowerCase().split(/[-_.@]/u);
+  if (language === "zh") return !rest.includes("hans") && rest.some(part => TRADITIONAL_CHINESE.has(part)) ? "zh-Hant" : "zh";
+  return Object.hasOwn(LOCALES, language) ? language : null;
+}
+
+/** The locale a fresh install uses: an explicit override, then the system's own language. */
+export function systemLocale(environment = process.env) {
+  for (const name of ["MOONDOG_LANGUAGE", "LC_ALL", "LC_MESSAGES", "LANG"]) {
+    // The C locale is a deliberate choice of plain English, not an unset value.
+    if (/^(?:c|posix)(?:[.@]|$)/iu.test(environment[name] ?? "")) return DEFAULT_LOCALE;
+    const locale = normalizeLocale(environment[name]);
+    if (locale) return locale;
+  }
+  return DEFAULT_LOCALE;
+}
+
+// Each language's name in the languages Moondog speaks. Traditional Chinese
+// comes before Chinese, because its names contain the word for Chinese.
+const LANGUAGE_NAMES = [
+  ["zh-Hant", /\btraditional\s+chinese\b|\bchino\s+tradicional\b|\bchin[eê]s\s+tradicional\b|\bchinois\s+traditionnel\b|\btraditionell\p{L}*\s+chinesisch\b|\bcinese\s+tradizionale\b|繁體|繁体|正體|번체/iu],
+  ["zh", /\b(?:chinese|mandarin|chino|chin[eê]s|chinois|chinesisch|cinese)\b|中文|汉语|漢語|普通话|普通話|华语|華語|中国語|중국어/iu],
+  ["en", /\b(?:english|ingl[eéê]s|anglais|englisch|inglese)\b|英文|英语|英語|영어/iu],
+  ["es", /\b(?:spanish|espa[nñ]ol|castellano|espanhol|espagnol|spanisch|spagnolo)\b|西班牙|スペイン語|스페인어/iu],
+  ["pt", /\b(?:portuguese|portugu[eéê]s|portugais|portugiesisch|portoghese)\b|葡萄牙|ポルトガル語|포르투갈어/iu],
+  ["ja", /\b(?:japanese|japon[eéê]s|japonais|japanisch|giapponese)\b|日本語|日语|日語|日文|일본어/iu],
+  ["ko", /\b(?:korean|coreano|cor[eé]en|koreanisch)\b|韩语|韓語|韩文|韓文|韩国语|韓國語|韓国語|한국어/iu],
+  ["fr", /\b(?:french|franc[eéê]s|fran[cç]ais|franz[öo]sisch|francese)\b|法语|法語|法文|フランス語|프랑스어/iu],
+  ["de", /\b(?:german|alem[aá]n|alem[ãa]o|allemand|deutsch|tedesco)\b|德语|德語|德文|ドイツ語|독일어/iu],
+  ["it", /\b(?:italian|italiano|italien|italienisch)\b|意大利|義大利|イタリア語|이탈리아어/iu],
+];
+// A Latin-script request names its language in one or two words ("in traditional Chinese").
+const NAMED = String.raw`(\p{L}+(?:[ \t]+\p{L}+)?)`;
+const EXPLICIT_REQUEST = new RegExp([
+  String.raw`(?<!\p{L})(?:reply|respond|answer|write|explain|speak|talk)(?:\s+(?:to me|this|it))?\s+in\s+${NAMED}`,
+  String.raw`(?<!\p{L})(?:responde(?:me)?|cont[eé]stame|escr[ií]beme|h[aá]blame|explica(?:me)?)\s+en\s+${NAMED}`,
+  String.raw`(?<!\p{L})(?:responda|responde|fale|escreva|explique)(?:-me)?\s+em\s+${NAMED}`,
+  String.raw`(?<!\p{L})(?:r[ée]ponds|r[ée]pondez|[ée]cris|[ée]crivez|parle|parlez|explique|expliquez)(?:-(?:moi|nous))?\s+en\s+${NAMED}`,
+  String.raw`(?<!\p{L})(?:antworte|antwortet|schreib|schreibe|sprich|erkl[äa]re?)(?:\s+(?:mir|uns|bitte|es|das))*\s+(?:auf|in)\s+${NAMED}`,
+  String.raw`(?<!\p{L})(?:rispondi(?:mi)?|scrivi(?:mi)?|parla(?:mi)?|spiega(?:mi)?)\s+in\s+${NAMED}`,
+  String.raw`(?:用|使用|以)\s*(\p{Script=Han}{2,4}?)\s*(?:跟我|和我|给我|給我|对我|對我)?\s*(?:回答|回复|回覆|回復|解释|解釋|说明|說明|输出|輸出|写|寫|讲|講|说|說)`,
+  String.raw`(\p{Script=Han}{2,4}|\p{Script=Katakana}{2,8}語)で(?:答|返事|返信|話|説明|書)`,
+  String.raw`((?:\p{Script=Hangul}+\s)?\p{Script=Hangul}{1,6}어)\s*로\s*(?:대답|답|말|설명|써|작성|응답|얘기|이야기)`,
+].join("|"), "giu");
+
+// Common characters whose Simplified and Traditional forms differ, including the
+// ones artist names and song titles use most. Text that uses only shared
+// characters decides nothing.
+const SIMPLIFIED = new Set("这们个来说时为会对后么过还发没问题听乐让给种点样经现从动进实与关开长东车门间爱气应头边见话认识办学体机无声华专辑队设电脑网络语写欢请谢帮换单张节数几吗调轻静觉场线团类风随暂继续该别荐试陈张刘杨黄赵吴郑许邓蒋孙马罗萧叶苏卢钟颜谭龙凤伟辉丽泪恋忆梦云飞岁湾国广岛离远谁娇录缘戏树桥涛剧艺术圣诞旧历压转响闹拥怀忧伤宝贝铁银钱号楼双归乡齐剑侠诗词兴举热愿读独奖优层简伦");
+const TRADITIONAL = new Set("這們個來說時為會對後麼過還發沒問題聽樂讓給種點樣經現從動進實與關開長東車門間愛氣應頭邊見話認識辦學體機無聲華專輯隊設電腦網絡語寫歡請謝幫換單張節數幾嗎調輕靜覺場線團類風隨暫繼續該別薦試裝佇陳誇張劉楊黃趙吳鄭許鄧蔣孫馬羅蕭葉蘇盧鍾顏譚龍鳳偉輝麗淚戀憶夢雲飛歲灣國廣島離遠誰嬌錄緣戲樹橋濤劇藝術聖誕舊歷壓轉響鬧擁懷憂傷寶貝鐵銀錢號樓雙歸鄉齊劍俠詩詞興舉熱願讀獨獎優層簡倫");
+
+function chineseLocale(prose, configured) {
+  let simplified = 0;
+  let traditional = 0;
+  for (const character of prose) {
+    if (SIMPLIFIED.has(character)) simplified += 1;
+    else if (TRADITIONAL.has(character)) traditional += 1;
+  }
+  if (simplified !== traditional) return traditional > simplified ? "zh-Hant" : "zh";
+  return configured === "zh-Hant" ? "zh-Hant" : "zh";
+}
+
+// Short function words and commands that are rare in the other Latin-script
+// languages. Words two languages share (de, que, para, una, con) decide nothing.
+const WORDS = {
+  en: new Set(["the", "an", "of", "and", "to", "play", "some", "song", "songs", "track", "tracks", "queue", "my", "i", "want",
+    "please", "what", "is", "are", "more", "like", "something", "music", "put", "next", "add", "find", "with", "for", "this",
+    "that", "it", "you", "can", "give", "thanks", "hi", "hello", "listen", "again", "stop", "skip", "pause", "who", "why", "how"]),
+  es: new Set(["la", "el", "los", "las", "una", "unos", "unas", "con", "pon", "ponme", "quiero", "canciones", "cancion",
+    "canción", "cola", "reproduce", "añade", "agrega", "otra", "otro", "más", "y", "mi", "mis", "es", "está", "del", "al",
+    "qué", "cómo", "dame", "escuchar", "gracias", "hola", "favor", "salta", "siguiente", "quién", "ahora", "vez"]),
+  pt: new Set(["você", "voce", "não", "nao", "uma", "umas", "um", "uns", "coloca", "coloque", "toque", "tocar", "adiciona",
+    "adicione", "quero", "músicas", "musicas", "fila", "mais", "também", "obrigado", "obrigada", "oi", "olá", "isso", "essa",
+    "esse", "da", "dos", "das", "na", "nas", "pra", "ela", "meu", "minha", "outra", "outro", "próxima", "agora", "ouvir",
+    "escutar", "põe", "bota", "pula", "favor", "tá", "está", "é"]),
+  fr: new Set(["le", "les", "des", "une", "et", "je", "j", "qu", "vous", "nous", "est", "pas", "mets", "mettre", "joue", "jouer",
+    "lance", "ajoute", "ajouter", "chanson", "chansons", "morceau", "morceaux", "musique", "attente", "quelque", "chose", "plus",
+    "encore", "merci", "bonjour", "salut", "plaît", "écouter", "écoute", "suivant", "suivante", "arrête", "quoi", "pourquoi",
+    "comment", "avec", "pour", "dans", "sur", "cette", "ça", "oui", "veux", "voudrais", "peux", "fais", "donne", "moi", "autre",
+    "maintenant", "aussi", "très", "trouve", "cherche", "montre", "recommande", "propose", "titre", "artiste", "groupe", "mon",
+    "aime", "jamais", "déjà", "nouveau", "nouvelle", "calme", "doux", "soir", "soirée", "enceinte", "téléphone", "ordinateur"]),
+  de: new Set(["der", "die", "den", "dem", "ein", "eine", "einen", "einem", "einer", "und", "ich", "du", "mir", "mich", "mein",
+    "meine", "meinen", "dir", "dich", "bitte", "spiel", "spiele", "spielen", "lied", "lieder", "musik", "warteschlange", "noch",
+    "mehr", "etwas", "wer", "wie", "warum", "ist", "nicht", "auch", "mit", "für", "von", "zu", "zum", "zur", "auf", "aus",
+    "danke", "hallo", "nächste", "nächsten", "nächstes", "jetzt", "gib", "zeig", "zeige", "suche", "finde", "füge", "füg",
+    "hinzu", "empfiehl", "mach", "kannst", "hast", "habe", "hab", "wieder", "nochmal", "nein", "sie", "wir", "uns", "einfach",
+    "ruhig", "ruhige", "ruhiges", "gerade", "gehört", "nie", "schon", "neue", "neues", "neuen", "bisschen", "paar", "titel",
+    "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",
+    "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",
+    "questa", "questo", "quella", "quello", "nella", "nel", "alla", "allo", "trova", "consiglia", "consigliami", "fai",
+    "proponi", "ferma", "sentire", "po", "già", "mai", "nuovo", "nuova", "nuove", "nuovi", "rilassante", "tranquillo",
+    "tranquilla", "stasera", "sera", "cassa", "telefono", "cellulare", "gruppo", "sentito", "ascoltato", "alza", "abbassa",
+    "piace", "piacciono"]),
+};
+const COMMANDS = {
+  en: new Set(["play", "queue", "put", "add", "find", "give", "skip", "pause", "stop", "show", "tell", "recommend", "make"]),
+  es: new Set(["pon", "ponme", "reproduce", "añade", "agrega", "busca", "dame", "salta", "muestra", "dime", "recomienda", "haz", "quiero"]),
+  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"]),
+};
+// Letters only one language writes are strong evidence; letters several share are weak evidence for each.
+const MARKS = [
+  [/[¿¡ñ]/u, ["es"]],
+  [/[ãõ]/u, ["pt"]],
+  [/[äöüß]/u, ["de"]],
+  [/[œæëïÿîû]/u, ["fr"]],
+  [/[ìò]/u, ["it"]],
+  [/[çâêô]/u, ["pt", "fr"]],
+  [/[èù]/u, ["fr", "it"]],
+  [/à/u, ["pt", "fr", "it"]],
+  [/[áíóú]/u, ["es", "pt"]],
+  [/é/u, ["es", "pt", "fr", "it"]],
+];
+
+function explicitLocale(prose) {
+  const requests = [...prose.matchAll(EXPLICIT_REQUEST)];
+  for (const match of requests.reverse()) {
+    const named = match.slice(1).find(Boolean);
+    const found = LANGUAGE_NAMES.find(([, pattern]) => pattern.test(named));
+    if (found) return found[0];
+  }
+  return null;
+}
+
+/**
+ * The language to answer one message in: an explicit request, then the
+ * 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) {
+  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);
+  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;
+  const kana = prose.match(/[\p{Script=Hiragana}\p{Script=Katakana}]/gu)?.length ?? 0;
+  if (hangul || kana) return hangul > kana ? "ko" : "ja";
+  // Han characters without kana are Chinese, Simplified or Traditional by their forms.
+  if (/\p{Script=Han}/u.test(prose)) return chineseLocale(prose, configured);
+  const lower = prose.normalize("NFC").toLocaleLowerCase();
+  const words = lower.match(/\p{L}+/gu) ?? [];
+  const scores = { en: 0, es: 0, pt: 0, fr: 0, de: 0, it: 0 };
+  for (const [pattern, locales] of MARKS) {
+    if (pattern.test(lower)) for (const locale of locales) scores[locale] += locales.length === 1 ? 3 : 1;
+  }
+  for (const locale of Object.keys(scores)) {
+    for (const word of words) if (WORDS[locale].has(word)) scores[locale] += 1;
+    if (COMMANDS[locale].has(words[0])) scores[locale] += 2;
+  }
+  const ranked = Object.entries(scores).sort(([, a], [, b]) => b - a);
+  return ranked[0][1] > ranked[1][1] ? ranked[0][0] : configured;
+}
+
+/** A lookup bound to one locale; a missing entry falls back to its parent language, then English. */
+export function translator(locale) {
+  const code = normalizeLocale(locale) ?? DEFAULT_LOCALE;
+  const catalogs = [CATALOGS[code], CATALOGS[PARENT[code]], CATALOGS.en].filter(Boolean);
+  const t = (key, params = {}) => {
+    const entry = catalogs.map(catalog => catalog[key]).find(value => value !== undefined);
+    if (entry === undefined) throw new Error(`Unknown message: ${key}`);
+    return typeof entry === "function" ? entry(params) : entry;
+  };
+  t.locale = code;
+  return t;
+}
+
+export function messageCatalogKeys(locale) {
+  return Object.keys(CATALOGS[locale] ?? {});
+}
+
+const fill = (text, params) => text.replace(/\{(\w+)\}/gu, (match, name) => params[name] ?? match);
+
+/**
+ * Screen text for one locale. Call tr("English sentence", { name }) with
+ * {name} placeholders, and tr.n(count, "{count} song", "{count} songs") for
+ * plurals. Keep the English as plain string literals: a test extracts them
+ * to check that every catalog translates every sentence.
+ */
+const screenTranslators = new Map();
+
+/** The language the terminal's screen text uses for a locale: its own, its parent's, or English. */
+export function screenLocale(locale) {
+  const code = normalizeLocale(locale) ?? DEFAULT_LOCALE;
+  if (SCREEN[code]) return code;
+  return SCREEN[PARENT[code]] ? PARENT[code] : DEFAULT_LOCALE;
+}
+
+export function screenTranslator(locale) {
+  const code = screenLocale(locale);
+  if (!screenTranslators.has(code)) screenTranslators.set(code, createScreenTranslator(code));
+  return screenTranslators.get(code);
+}
+
+function createScreenTranslator(code) {
+  const catalog = SCREEN[code];
+  const numbers = new Intl.NumberFormat(intlLocale(code));
+  const plurals = new Intl.PluralRules(intlLocale(code));
+  const tr = (english, params = {}) => fill(typeof catalog[english] === "string" ? catalog[english] : english, params);
+  tr.n = (count, one, other, params = {}) => {
+    const values = { ...params, count: Number.isFinite(count) ? numbers.format(count) : count };
+    const entry = catalog[other];
+    if (typeof entry === "string") return fill(entry, values);
+    if (entry && typeof entry === "object") return fill(entry[plurals.select(count)] ?? entry.other, values);
+    return fill(count === 1 ? one : other, values);
+  };
+  tr.number = value => Number.isFinite(value) ? numbers.format(value) : value;
+  // For a sentence marked with N_() where it was defined, such as a command list.
+  tr.marked = (english, params = {}) => tr(english, params);
+  tr.locale = code;
+  return tr;
+}
+
+/** Marks an English sentence for extraction where no translator exists yet. */
+export const N_ = text => text;
+
+/** A translator that follows a changing locale, such as the /language choice. */
+export function liveScreenTranslator(getLocale) {
+  const current = () => screenTranslator(getLocale());
+  const tr = (english, params) => current()(english, params);
+  tr.n = (...args) => current().n(...args);
+  tr.number = value => current().number(value);
+  tr.marked = (english, params) => current().marked(english, params);
+  Object.defineProperty(tr, "locale", { get: () => current().locale });
+  return tr;
+}
+
+export function screenCatalog(locale) {
+  return SCREEN[locale] ?? {};
+}

package/src/i18n/messages/de.mjs

@@ -0,0 +1,135 @@
+// 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.avoided": "An Spotify wurde nichts gesendet: Du wolltest diesen Künstler oder diesen Song nicht mehr hören. Sag mir jederzeit, wenn du das ändern willst.",
+  "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.`,
+  "plan.avoidedLeftOut": ({ titles }) => `Weggelassen, weil du sie nicht mehr hören wolltest: ${titles}.`,
+  "queue.skippedKnown": ({ count }) => `${count} Titel aus deinem Hörverlauf übersprungen, wie gewünscht.`,
+  "queue.mix": ({ familiar = 0, returning = 0, heard = 0, known_artist: knownArtist = 0, new: fresh = 0 }) =>
+    `Laut deinem Hörverlauf: ${[familiar && `${familiar} gut bekannt`, returning && `${returning} nach längerer Zeit wieder`, heard && `${heard} ein- oder zweimal gehört`, knownArtist && `${knownArtist} neu von ${knownArtist === 1 ? "einem bekannten Künstler" : "bekannten Künstlern"}`, fresh && `${fresh} neu für dich`].filter(Boolean).join(", ")}.`,
+  "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.",
+  "choice.like": ({ title, artist }) => { const name = title ? `„${title}“ von ${artist}` : artist; return `\n\nGespeichert: Du magst ${name}. Sag mir jederzeit, wenn du das ändern willst.`; },
+  "choice.avoid": ({ title, artist }) => { const name = title ? `„${title}“ von ${artist}` : artist; return `\n\nGespeichert: Ich lasse ${name} aus allem heraus, was ich spiele und vorschlage. Sag mir jederzeit, wenn du das ändern willst.`; },
+  "choice.retract": ({ title, artist }) => { const name = title ? `„${title}“ von ${artist}` : artist; return `\n\nZurückgenommen: deine frühere Wahl zu ${name}.`; },
+  "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,136 @@
+// 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.avoided": "Nothing was sent to Spotify: you asked me to keep that artist or song out of what I play. Tell me any time to change it.",
+  "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.`,
+  "plan.avoidedLeftOut": ({ titles }) => `Left out because you asked me to keep them out: ${titles}.`,
+  "queue.skippedKnown": ({ count }) => `Skipped ${count} tracks matched in retained history, as requested.`,
+  "queue.mix": ({ familiar = 0, returning = 0, heard = 0, known_artist: knownArtist = 0, new: fresh = 0 }) =>
+    `The mix: ${[familiar && `${familiar} you know well`, returning && `${returning} back after a while`, heard && `${heard} you've heard once or twice`, knownArtist && `${knownArtist} new from ${knownArtist === 1 ? "an artist" : "artists"} you know`, fresh && `${fresh} new to you`].filter(Boolean).join(", ")}.`,
+  "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.",
+  "choice.like": ({ title, artist }) => { const name = title ? `"${title}" by ${artist}` : artist; return `\n\nSaved: you like ${name}. Tell me any time to change it.`; },
+  "choice.avoid": ({ title, artist }) => { const name = title ? `"${title}" by ${artist}` : artist; return `\n\nSaved: I'll keep ${name} out of what I play and suggest. Tell me any time to change it.`; },
+  "choice.retract": ({ title, artist }) => { const name = title ? `"${title}" by ${artist}` : artist; return `\n\nUndone: your earlier choice about ${name}.`; },
+  "turn.cancelled": "Cancelled further work.",
+  "turn.interrupted": "The response was interrupted. The recorded Spotify outcomes are below; no action was replayed.",
+};