@audiofool/moondog 0.1.0 → 0.2.0-beta.3

package/src/core/playback-preferences.mjs

@@ -0,0 +1,97 @@
+import { unwatchFile, watchFile } from "node:fs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+
+import { resolveMoondogAuthFile } from "../runtime/pi/persistent-credential-store.mjs";
+
+// The music service that plays songs. Apple Music plays whole songs or 30-second previews;
+// NetEase Cloud Music plays through its own ncm-cli, for listeners in mainland China.
+export const PLAYBACK_SERVICES = Object.freeze(["spotify", "apple_music", "netease"]);
+export const DEFAULT_PLAYBACK_SERVICE = "spotify";
+
+export function normalizePlaybackService(value) {
+  return PLAYBACK_SERVICES.includes(value) ? value : null;
+}
+
+// One selection for every conversation in this process. The window and the terminal each run one,
+// and watchPlaybackPreference keeps it in step with the other's saves.
+// Persist before publishing a change; overlapping choices save in the order they were requested.
+// The file is written even when this process already holds the value: the other may have changed it.
+export function createPlaybackSelection({ service = DEFAULT_PLAYBACK_SERVICE, save } = {}) {
+  let current = normalizePlaybackService(service) ?? DEFAULT_PLAYBACK_SERVICE;
+  let changing = Promise.resolve();
+  const listeners = new Set();
+  const set = (service) => {
+    const value = normalizePlaybackService(service);
+    if (!value) throw new Error(`Unsupported music service: ${service}`);
+    if (value !== current) {
+      current = value;
+      for (const listener of listeners) {
+        try { listener(value); } catch { /* A surface cannot undo a saved choice. */ }
+      }
+    }
+    return value;
+  };
+  return {
+    get service() { return current; },
+    set,
+    change(service) {
+      const work = changing.then(async () => {
+        const value = normalizePlaybackService(service);
+        if (!value) throw new Error(`Unsupported music service: ${service}`);
+        await save?.(value);
+        return set(value);
+      });
+      changing = work.catch(() => {});
+      return work;
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+  };
+}
+
+// Kept next to the language preference, apart from runtime settings.
+export function resolvePlaybackPreferenceFile(environment = process.env) {
+  return path.join(path.dirname(resolveMoondogAuthFile(environment)), "playback.json");
+}
+
+export async function readPlaybackPreference(environment = process.env) {
+  try {
+    const document = JSON.parse(await readFile(resolvePlaybackPreferenceFile(environment), "utf8"));
+    return document?.version === 1 ? normalizePlaybackService(document.service) : null;
+  } catch {
+    // A missing or unreadable preference falls back to Spotify.
+    return null;
+  }
+}
+
+export async function writePlaybackPreference(service, environment = process.env) {
+  const value = normalizePlaybackService(service);
+  if (!value) throw new Error(`Unsupported music service: ${service}`);
+  const file = resolvePlaybackPreferenceFile(environment);
+  await mkdir(path.dirname(file), { recursive: true, mode: 0o700 });
+  await writeFile(file, `${JSON.stringify({ version: 1, service: value }, null, 2)}\n`, { encoding: "utf8", mode: 0o600 });
+  return value;
+}
+
+// The terminal and the window each run their own core on this file. A service saved by one reaches
+// the other's selection, which tells its picker and agents; onChange hears only those changes.
+export function watchPlaybackPreference(selection, { environment = process.env, interval = 2000, onChange } = {}) {
+  const file = resolvePlaybackPreferenceFile(environment);
+  const follow = async () => {
+    const saved = await readPlaybackPreference(environment);
+    if (!saved || saved === selection.service) return;
+    selection.set(saved);
+    onChange?.(saved);
+  };
+  const listener = () => { void follow().catch(() => {}); };
+  watchFile(file, { interval, persistent: false }, listener);
+  return () => unwatchFile(file, listener);
+}
+
+/** The saved choice, or Spotify. */
+export async function resolvePlaybackService(environment = process.env) {
+  return await readPlaybackPreference(environment) ?? DEFAULT_PLAYBACK_SERVICE;
+}

package/src/core/spotify-listening-intent.mjs

@@ -0,0 +1,124 @@
+// These parsers read only the actual listener message. Metadata and model tool
+// arguments never create a contextual selection or an additional write grant.
+const digits = { 一: 1, 二: 2, 两: 2, 三: 3, 四: 4, 五: 5, 六: 6, 七: 7, 八: 8, 九: 9 };
+function number(value) {
+  if (/^\d+$/u.test(value)) return Number(value);
+  if (/^[一二两三四五六七八九]?十[一二三四五六七八九]?$/u.test(value)) {
+    const [tens, ones] = value.split("十");
+    return (digits[tens] ?? 1) * 10 + (digits[ones] ?? 0);
+  }
+  return digits[value] ?? null;
+}
+
+const englishCounts = { zero: 0, one: 1, two: 2, three: 3, four: 4, five: 5, six: 6, seven: 7, eight: 8, nine: 9,
+  ten: 10, eleven: 11, twelve: 12, thirteen: 13, fourteen: 14, fifteen: 15, sixteen: 16, seventeen: 17, eighteen: 18, nineteen: 19,
+  twenty: 20, thirty: 30, forty: 40, fifty: 50, sixty: 60, seventy: 70, eighty: 80, ninety: 90, hundred: 100, thousand: 1000, million: 1000000 };
+const englishCountWords = Object.keys(englishCounts).join("|");
+const englishCountPattern = `(?:${englishCountWords})(?:(?:[ -]+)(?:and +)?(?:${englishCountWords}))*`;
+const leadingEnglishCount = new RegExp(`^${englishCountPattern}\\b`, "iu");
+const mediaCounts = new RegExp(`(?<![\\p{L}\\p{N}])(?:[+-]?(?:\\d+(?:\\.\\d+)?|\\.\\d+)|${englishCountPattern})(?![\\p{L}\\p{N}])`, "giu");
+
+function queueCount(command) {
+  const value = command.replace(/^(?:(?:only|just|exactly|another|an additional|a further|the next)\s+)+/iu, "").trim();
+  if (/^(?:no|none|nothing)\b/iu.test(value)) return 0;
+  // Chinese quantities may follow 找/推荐/刚才的 inside the accepted command.
+  const chinese = [...value.matchAll(/([零〇一二两三四五六七八九十百千万亿]+|[+-]?\d+(?:\.\d+)?)\s*首/gu)];
+  if (chinese.length > 1) return 0;
+  if (chinese.length === 1) return /^[+-]?\d/u.test(chinese[0][1]) ? Number(chinese[0][1]) : number(chinese[0][1]) ?? 0;
+  const tokens = [...value.matchAll(mediaCounts)];
+  if (tokens.some(match => /^\s*(?:[-/]|\b(?:and|or|to|through|point)\b)/iu.test(value.slice(match.index + match[0].length)))) return 0;
+  const media = tokens.filter(match => /^\s+(?:(?!\bby\b)[^\s,;]+\s+){0,8}(?:songs?|tracks?)\b/iu.test(value.slice(match.index + match[0].length)));
+  if (media.length > 1) return 0;
+  const numeric = value.match(/^[+-]?(?:\d+(?:\.\d+)?|\.\d+)(?![\p{L}\p{N}])/u);
+  const english = value.match(leadingEnglishCount);
+  const count = numeric ?? english ?? media[0];
+  if (!count) return /^(?:a|an)\s+(?:song|track)\b/iu.test(value) ? 1 : null;
+  const tail = value.slice(count.index + count[0].length);
+  // Number words in titles (Two Princes, Seven Nation Army) are not quantities.
+  if (!media.length && english && tail.trim()) return null;
+  if (/^[+\-.\d]/u.test(count[0])) return Number(count[0]);
+  const words = count[0].toLowerCase().split(/[ -]+/u);
+  if (words.length === 1) return englishCounts[words[0]];
+  if (words.length === 2 && englishCounts[words[0]] >= 20 && englishCounts[words[0]] < 100 && englishCounts[words[1]] < 10) return englishCounts[words[0]] + englishCounts[words[1]];
+  return 0; // Unsupported compound quantities cannot fall back to the candidate pool.
+}
+
+function queueCommand(clause, hasQueue) {
+  const value = clause.trim().replace(/^(?:(?:please|can you|could you|would you|will you|i want (?:you )?to|i would like (?:you )?to)\s+)+/iu, "");
+  if (/^(?:请|帮我|给我|可以|能否)*(?:问|告诉|解释|说明|介绍|看看|查看|检查|显示|列出|读取|怎么|如何|为什么)/u.test(value)) return null;
+  const queue = value.match(/^queue\s+(.+)/iu);
+  if (queue && !/^(?:has|have|had|is|are|was|were|will|would|can|could|should|must|may|might|does|doesn't|do|don't|did|didn't|keeps?|contains?|includes?|needs?|looks?|seems?|already|currently|status|length|size)\b/iu.test(queue[1])) return queue[1];
+  const additive = value.match(/^(?:add|put|place)\s+(.+?)\s+(?:to|into|in|on)\s+(?:(?:the|my)\s+)?queue\b/iu);
+  if (additive) return additive[1];
+  const chineseAdditive = value.match(/^(?:(?:请|帮我|给我)\s*)?(?:加|放|排)\s*(.+?)(?:到|进)(?:我的)?队列/u);
+  if (chineseAdditive) return chineseAdditive[1];
+  if (hasQueue && /^(?:再来|给我|帮我|请|把|将|加入队列|加到队列|放到队列|排进队列)/u.test(value)) {
+    return value.replace(/^(?:(?:再来|给我|帮我|请|把|将|加入队列|加到队列|放到队列|排进队列)\s*)+/u, "");
+  }
+  return null;
+}
+
+export function queueCancellationRequested(text) {
+  if (typeof text !== "string") return false;
+  const value = text.normalize("NFKC").replace(/[‘’]/gu, "'").trim();
+  return /^[¡]?(?:cancel|stop|算了|取消|不用了|别加了|不要加了|cancela|cancelar|para|detente|d[eé]jalo|olv[ií]dalo|ya no)[.!。！]?$/iu.test(value) ||
+    /\b(?:don't|do not|never|stop|cancel|not to)\b[^,，。;；!?！？]*\bqueue\b|(?:不要|别|取消|停止)[^，。!?！？]{0,40}(?:queue|队列)/iu.test(value) ||
+    /(?:^|[\s¡¿,])(?:no|nunca|deja de|para de|cancela)\s[^,.;!?¡¿]{0,40}\bcola\b/iu.test(value) ||
+    /^(?:cancela|cancelar|para|pare|chega|esquece|deixa pra l[aá])[.!]?$/iu.test(value) ||
+    /(?:^|[\s,])(?:n[aã]o|nunca|para de|pare de|cancela)\s[^,.;!?]{0,40}\bfila\b/iu.test(value) ||
+    /^(?:キャンセル|やめて|止めて|中止)(?:して)?(?:ください)?[。！!]?$|(?:キュー|再生待ち)[^。！？]{0,20}(?:入れないで|追加しないで|やめて)|追加しないで/u.test(value);
+}
+
+/**
+ * The listener asked for music they have not heard, in any supported language. "Not heard" counts
+ * only when it ends there or says yet, before or ever: "haven't heard in a while" asks to come back.
+ */
+export function unheardRequested(text) {
+  return typeof text === "string" &&
+    /没听过|从未听|不要听过|\bunheard\b|\bnever (?:heard|listened to)\b|\b(?:haven't|have not|'ve not|not)\s+(?:yet\s+|ever\s+)?(?:heard|listened to)(?:\s+(?:yet|before|of|ever|please)\b|\s*(?:$|[,.;!?，。；！？]))|\bnew (?:to|for) me\b|\bunfamiliar\b|outside.*library|曲库之外|nunca he (?:escuchado|o[ií]do)|que no (?:he|haya) (?:escuchado|o[ií]do)|sin escuchar|nuevas para m[ií]|nunca ouvi|que eu (?:ainda )?n[aã]o (?:ouvi|conhe[cç]o)|novas pra mim|novas para mim|聴いたことのない|聞いたことのない|知らない曲|未聴/iu.test(text.replace(/[\u2018\u2019]/gu, "'"));
+}
+
+function queueRefinement(value, previous) {
+  if (!previous || previous.attempted || value.length > 500) return null;
+  // A count or musical version choice completes a recent, unfinished listener
+  // request. It never creates authority without that original queue request.
+  const clauses = value.split(/[,，。;；!?！？\n]|\.(?:\s|$)/u).map(clause => clause.trim()).filter(Boolean);
+  const countStart = new RegExp(`^(?:${englishCountPattern}|[+-]?(?:\\d+(?:\\.\\d+)?|\\.\\d+))\\s+(?:more\\s+)?(?:songs?|tracks?)\\b`, "iu");
+  const counts = clauses.filter(clause =>
+    /^(?:(?:队列(?:数量|首数)?|数量|首数)\s*(?:先来|就要|来|要|改成|改为)?|先来|来|就要|改成|改为)?\s*(?:[零〇一二两三四五六七八九十百千万亿]+|[+-]?\d+(?:\.\d+)?)\s*首/u.test(clause) ||
+    (countStart.test(clause) && !/\b(?:are|is|were|was|already|have|has|had)\b/iu.test(clause)))
+    .map(queueCount).filter(count => count !== null);
+  const choice = value.replace(/[,，.!。！?？]/gu, " ").trim();
+  const versionChoice = /^(?:(?:掺|混|加|选|用|要|就|还是|只要|一点|一些|纯)\s*)*(?:翻唱|原唱|现场|录音室|女声|男声|纯音乐|老歌)(?:版本|版|气质)?(?:\s*(?:和|加|也|都|一点|一些|吧|的|翻唱|原唱|现场|录音室|女声|男声|纯音乐|老歌))*$/u.test(choice) ||
+    /^(?:(?:mix in|include|add|choose|use|only|just|some|a few)\s+)*(?:covers?|originals?|original versions?|live versions?|studio versions?|instrumentals?|female vocals?|male vocals?)(?:\s+please)?$/iu.test(choice);
+  if (!counts.length && !versionChoice) return null;
+  const ambiguous = counts.length > 1 || /[,，;；]\s*(?:actually|instead|make that|only|改成|改为|其实)/iu.test(value);
+  return { requested: ambiguous ? 0 : counts[0] ?? previous.requested,
+    request: previous.request, refinement: value, queue_only: true,
+    excludeKnown: previous.excludeKnown === true };
+}
+
+export function queueListeningIntent(text, previous = null) {
+  if (typeof text !== "string" || text.length > 2000) return null;
+  const value = text.normalize("NFKC").replace(/[‘’]/gu, "'").trim().replace(/\b\d{1,3}(?:,\d{3})+(?:\.\d+)?\b/gu, count => count.replaceAll(",", ""));
+  const hasQueue = /\bqueue\b|播放队列|(?:加入|加到|放到|排进|到|进)(?:我的)?队列/iu.test(value);
+  if (queueCancellationRequested(value) ||
+      /\b(?:explain|describe|what(?:'s| is)|why|how|whether|tell me about|can i|should i|do i|does|show|inspect|list|read|check)\b.*\bqueue\b|^(?:为什么|怎么|如何|查看|看看|显示|读取|队列里|请问|(?:帮我|给我)(?:看看|解释|说明|介绍)|(?:请|可以|能否)?(?:解释|说明|介绍))/iu.test(value)) return null;
+  if (!hasQueue) return queueRefinement(value, previous);
+  // A correction can reuse only the host's recent request, including its receipt.
+  const correction = /^(?:i meant (?:the )?queue(?:\s*[,，]?\s*not (?:a )?playlist)?|queue\s*[,，]\s*not (?:a )?playlist|(?:我)?要的是\s*queue\s*[,，]?\s*不是歌单)[.!。！]?$/iu.test(value);
+  if (correction && !previous) return null;
+  const clauses = value.split(/[,，。;；!?！？]|\.(?:\s|$)/u);
+  const commands = correction ? [] : clauses.map(clause => queueCommand(clause, hasQueue)).filter(command => command !== null);
+  if (!correction && commands.length === 0) return queueRefinement(value, previous);
+  const counts = commands.map(queueCount);
+  // Multiple commands or a revised quantity need an exact request before writing.
+  const ambiguous = commands.length > 1 || (counts[0] === null && clauses.some(clause => queueCommand(clause, hasQueue) === null && queueCount(clause) !== null)) || /\d,\d/u.test(value) || /[,，;；]\s*(?:actually|instead|make that|only|改成|改为|其实)/iu.test(value);
+  const requested = correction ? previous.requested : ambiguous ? 0 : counts[0];
+  const affirmative = value.replace(/(?:don't|don’t|do not|never)\s+[^,，.;；]+|(?:不要|别)[^，。;；]+/giu, "").replaceAll("播放队列", "队列");
+  return { requested,
+    request: correction ? previous.request : value,
+    queue_only: correction || !/\b(?:play|resume|pause|skip|next|previous|seek|volume|shuffle|repeat|transfer|save|create|follow|unfollow)\b|播放|暂停|下一首|上一首|音量|切换设备|保存|创建|关注/iu.test(affirmative),
+    ...(correction && previous.attempted ? { clarification_only: true } : {}),
+    excludeKnown: unheardRequested(value) || (correction && previous.excludeKnown === true) };
+}

package/src/core/synthetic-domain-services.mjs

@@ -252,7 +252,7 @@ function safeTrackResult(track) {
       result.discovery_basis = structuredClone(track.discoveryBasis);
     }
     result.knownness = {
-      imported_library: "not_found_by_exact_title_artist",
+      imported_library: track.knownLibraryMatch ? "found_by_exact_title_artist" : "not_found_by_exact_title_artist",
       listening_history: "not_checked",
     };
     if (track.primaryGenre) result.primary_genre = track.primaryGenre;
@@ -962,6 +962,21 @@ export class SyntheticDomainServices {
     }
   }
 
+  // Each conversation that runs beside another gets a fork. It shares the fixture's tracks,
+  // profile and evidence, which never change after construction, and keeps its own candidate
+  // sets and outside tracks, so one conversation's prompt never clears another's.
+  fork() {
+    const fork = new SyntheticDomainServices({
+      subjectScope: this.#subjectId,
+      fixture: { tracks: [] },
+    });
+    fork.#tracks = this.#tracks;
+    fork.#tracksById = new Map(this.#tracks.map((track) => [track.trackRefId, track]));
+    fork.#profile = this.#profile;
+    fork.#evidenceById = this.#evidenceById;
+    return fork;
+  }
+
   status() {
     return {
       state: "ready",
@@ -990,6 +1005,11 @@ export class SyntheticDomainServices {
     return { invalidated_candidate_sets: invalidated };
   }
 
+  // There is no store to close; a closed instance only lets go of its prompt state.
+  close() {
+    this.resetCandidateSets();
+  }
+
   async searchLibrary(argumentsValue) {
     const input = modelArguments(
       argumentsValue,
@@ -1064,7 +1084,7 @@ export class SyntheticDomainServices {
     };
   }
 
-  registerExternalCandidateSet({ tracks, source } = {}) {
+  registerExternalCandidateSet({ tracks, source, excludeKnown = true } = {}) {
     const provider =
       isPlainObject(source) && externalCatalogProviders.has(source.provider)
         ? source.provider
@@ -1101,10 +1121,11 @@ export class SyntheticDomainServices {
           normalizeSearchText(track.artistCredit) ===
             normalizeSearchText(internal.artistCredit),
       );
-      if (libraryMatch) {
+      if (excludeKnown && libraryMatch) {
         excludedLibraryMatches += 1;
         continue;
       }
+      internal.knownLibraryMatch = libraryMatch;
       if (this.#tracksById.has(internal.trackRefId)) {
         fail("external_candidate_invalid", "External catalog candidates are duplicated.");
       }

package/src/core/track-title.mjs

@@ -0,0 +1,107 @@
+// A remaster, a live take or a guest credit names a recording of the same song, so knownness,
+// deduplication and Moondog's suggestion ledger compare titles without these suffixes:
+// " - 2011 Remaster", "(Remastered 2009)", " - Live", "(feat. X)", "[Deluxe]". A remix stays
+// its own song.
+const DASH_SUFFIX = /\s+[-\u2013\u2014]\s+[^-\u2013\u2014]*\b(?:remaster(?:ed)?|live|mono|stereo|single|radio edit|edit|version|demo|acoustic|bonus track|\d{4} mix)\b[^-\u2013\u2014]*$/iu;
+const BRACKET_SUFFIX = /\s*[([][^()[\]]*\b(?:remaster(?:ed)?|live|feat\.?|ft\.?|featuring|with|deluxe|mono|stereo|version|edit|demo|acoustic|bonus track)(?:\b|(?<=\.))[^()[\]]*[)\]]$/iu;
+
+export function normalizedTrackTitle(value) {
+  let title = String(value ?? "").normalize("NFKC").toLocaleLowerCase("und").replace(/\s+/gu, " ").trim();
+  for (let previous = null; previous !== title;) {
+    previous = title;
+    const stripped = title.replace(DASH_SUFFIX, "").replace(BRACKET_SUFFIX, "").trim();
+    // A title made only of a version word stays as it is.
+    if (stripped) title = stripped;
+  }
+  return title;
+}
+
+export function normalizedArtistName(value) {
+  return String(value ?? "").normalize("NFKC").toLocaleLowerCase("und").replace(/\s+/gu, " ").trim();
+}
+
+/**
+ * One song by one primary artist, whatever the recording's version suffix. A unit separator
+ * joins the two, not a NUL: node:sqlite on Node 22 cuts a stored string at a NUL.
+ */
+export function trackMatchKey(title, artist) {
+  const name = normalizedTrackTitle(title);
+  const credit = normalizedArtistName(artist);
+  return name && credit ? `${name}\u001f${credit}` : null;
+}
+
+// Chinese, Japanese and Korean text, which has no spaces between words (or words
+// that take particles), so a name in it is found as a substring.
+const CJK_TEXT = /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}]/u;
+
+// Folds case, width, Latin accents and punctuation, so "Beyoncé," and "beyonce" read alike.
+// Kana voicing marks stay, because they change the word.
+export function foldedWords(value) {
+  return String(value ?? "").normalize("NFKD").replace(/[̀-ͯ]/gu, "").normalize("NFC")
+    .toLocaleLowerCase("und").replace(/[^\p{L}\p{N}\p{M}]+/gu, " ").trim();
+}
+
+export const isCjkText = (value) => CJK_TEXT.test(String(value ?? ""));
+
+// A letter or digit of a script that writes its words apart. A name must not start or end
+// next to one of these when its own edge is one too; next to a CJK character, a space or
+// punctuation, it may, so "Coldplay" is named in "我不想再听Coldplay了".
+const SPACED_LETTER = /[[\p{L}\p{N}\p{M}]--[\p{scx=Han}\p{scx=Hiragana}\p{scx=Katakana}\p{scx=Hangul}]]/v;
+const joined = (left, right) => left !== undefined && right !== undefined && SPACED_LETTER.test(left) && SPACED_LETTER.test(right);
+
+/**
+ * Whether text names a name. A script change (Latin next to CJK), a space or punctuation ends
+ * a word, and between two Latin letters a name matches only as whole words.
+ * A name shorter than 2 characters after folding names nothing.
+ */
+export function textNames(text, name) {
+  const wanted = foldedWords(name);
+  if (Array.from(wanted.replace(/ /gu, "")).length < 2) return false;
+  const haystack = foldedWords(text);
+  const first = Array.from(wanted)[0];
+  const last = Array.from(wanted).at(-1);
+  for (let at = haystack.indexOf(wanted); at >= 0; at = haystack.indexOf(wanted, at + 1)) {
+    const before = Array.from(haystack.slice(0, at)).at(-1);
+    const after = Array.from(haystack.slice(at + wanted.length))[0];
+    if (!joined(before, first) && !joined(last, after)) return true;
+  }
+  return false;
+}
+
+/** Whether the listener's text names this song, by its title without version suffixes. */
+export function textNamesTitle(text, title) {
+  return textNames(text, normalizedTrackTitle(title));
+}
+
+// Articles that start band names in the supported languages: "Beatles" names "The Beatles".
+const LEADING_ARTICLE = /^(?:the|an|a|los|las|el|la|les|le|l|die|der|das|il|lo|i|gli|os|as|o) (?=\S)/u;
+
+/** Whether text names an artist, with or without a leading article. */
+export function textNamesArtist(text, artist) {
+  const name = foldedWords(artist);
+  const bare = name.replace(LEADING_ARTICLE, "");
+  // "The The" keeps its article: a bare article names nothing.
+  return textNames(text, name) || (bare !== name && !LEADING_ARTICLE.test(`${bare} x`) && textNames(text, bare));
+}
+
+// A quoted name: straight or curly double or single quotes, corner brackets, title marks or
+// guillemets. A straight or curly single quote inside a word is an apostrophe.
+const QUOTED = [/"([^"]+)"/gu, /“([^“”]+)”/gu, /„([^„“”]+)[“”]/gu, /«([^«»]+)»/gu, /「([^「」]+)」/gu, /『([^『』]+)』/gu,
+  /《([^《》]+)》/gu, /(?<![\p{L}\p{N}])'(?=(.+?)'(?![\p{L}\p{N}]))/gu, /‘(.+?)’(?![\p{L}\p{N}])/gu];
+
+/** Whether text quotes this song's title, version suffixes aside. */
+export function textQuotesTitle(text, title) {
+  const wanted = foldedWords(normalizedTrackTitle(title));
+  return Boolean(wanted) && QUOTED.some((pattern) => Array.from(String(text ?? "").matchAll(pattern))
+    .some(([, quoted]) => foldedWords(normalizedTrackTitle(quoted)) === wanted));
+}
+
+/**
+ * Whether the listener's text names this song as their own pick: its title with one of its
+ * credited artists, or its title in quotes. A title alone ("play Pink Moon") is not enough,
+ * because an open request shares words with titles ("a rainy day", "安静").
+ */
+export function textNamesSong(text, title, artists = []) {
+  return textQuotesTitle(text, title) ||
+    (textNamesTitle(text, title) && artists.some((artist) => textNamesArtist(text, artist)));
+}

package/src/demo/moondog-demo.mjs

@@ -65,30 +65,12 @@ const offlineSteps = Object.freeze({
 
 const demoNextSteps = Object.freeze([
   Object.freeze({
-    id: "open_visual_tour",
-    title: "Open the visual Listening Time Machine",
-    checkout_command: "npm run demo:studio",
-    installed_command: "moondog studio --demo",
-    data_boundary:
-      "The fictional tour stays on 127.0.0.1, reads no private history, rejects imports, and keeps corrections only in process memory.",
-  }),
-  Object.freeze({
-    id: "open_session_studio",
-    title: "Open your history without importing it",
-    checkout_command:
-      "npm --silent run demo:studio -- --from /absolute/path/to/spotify-history.zip",
-    installed_command:
-      "moondog studio --from /absolute/path/to/spotify-history.zip",
-    data_boundary:
-      "No dependency installation is required. The archive stays unchanged, the private profile and corrections live only in process memory, and no model, provider, cloud, or network request is made.",
-  }),
-  Object.freeze({
-    id: "open_private_studio",
+    id: "open_listening_room",
     title: "Bring your own listening history",
-    checkout_command: "npm run studio",
-    installed_command: "moondog studio",
+    checkout_command: "npm start",
+    installed_command: "moondog",
     data_boundary:
-      "Studio stays on 127.0.0.1. The fictional preview saves nothing. Import changes private local state only after an explicit button press.",
+      "Your listening room opens in this terminal. Type /import there; Moondog shows what is inside an export before anything is saved.",
   }),
 ]);