@audiofool/moondog 0.3.0-beta.1 → 0.3.0-beta.11

package/src/integrations/stable-audio/sources.mjs

@@ -0,0 +1,106 @@
+// The official sources Moondog's one-click setup downloads Stable Audio 3 from, each pinned to
+// the release, commit or snapshot tested with Moondog on Apple silicon, and the files every
+// download is verified against. Nothing here is fetched until the listener asks for a model.
+
+// The models a listener can choose, with the flags sa3_mlx.py takes and the weights text to music
+// loads. The codec encoder is only for --init-audio, so it is never downloaded.
+export const STABLE_AUDIO_MODELS = Object.freeze({
+  medium: Object.freeze({ dit: "medium", decoder: "same-l", receipt: "sa3-medium-ARC", weights: Object.freeze(["dit_medium_f16.npz", "same_l_decoder_f32.npz"]) }),
+  "small-music": Object.freeze({ dit: "sm-music", decoder: "same-s", receipt: "sa3-sm-music-ARC", weights: Object.freeze(["dit_sm-music_f16.npz", "same_s_decoder_f32.npz"]) }),
+});
+export const DEFAULT_STABLE_AUDIO_MODEL = "medium";
+// The text encoder every model needs.
+export const SHARED_WEIGHTS = Object.freeze(["t5gemma_f16.npz"]);
+export const isStableAudioModel = (value) => typeof value === "string" && Object.hasOwn(STABLE_AUDIO_MODELS, value);
+
+const HF_SNAPSHOT = "08b17423649b5714b22eab20f96bf00751f2358a";
+const CODE_COMMIT = "77e0398c26f7d22d801ec1bb036307e8b231f741";
+
+export const STABLE_AUDIO_SOURCES = Object.freeze({
+  // uv makes the Python environment, so the listener installs nothing.
+  uv: Object.freeze({
+    version: "0.9.7",
+    url: "https://github.com/astral-sh/uv/releases/download/0.9.7/uv-aarch64-apple-darwin.tar.gz",
+    size: 18_372_336,
+    sha256: "35572b9619fc14d67fc1cd72582c3cfc5c9c66d97f310192e04f26fb3fe96005",
+  }),
+  // Stability AI's code (MIT). A GitHub tarball's bytes may change between downloads, so each file
+  // extracted is checked against this manifest instead: [path in optimized/mlx, bytes, sha256].
+  code: Object.freeze({
+    commit: CODE_COMMIT,
+    url: `https://codeload.github.com/Stability-AI/stable-audio-3/tar.gz/${CODE_COMMIT}`,
+    folder: `stable-audio-3-${CODE_COMMIT}/optimized/mlx`,
+    files: Object.freeze([
+      [".gitignore", 420, "0dbc69aa372ac835f6ec00d4d18941443993b9d357722e6775857544eb0b4fa3"],
+      ["README.md", 20260, "5fce0300becfed583577b0e0afacf6f68696196cd6597f136a455b17269e5c31"],
+      ["TRAINING_CONVENTIONS.md", 14933, "3e915aefada47d3c56dc53f0fafd8ba274df0213b3cd6fb0d986e10420c1c727"],
+      ["ableton/AudioInserter/AudioInserter.py", 5573, "9f318c73c8f4b81f15adb9d853334c9e6f8411e907044fb8c933e5c1fa98ef20"],
+      ["ableton/AudioInserter/__init__.py", 112, "8530d242ecf41046d7e88b3e3aed707e2faa039db33630769dcfcdc297aa046c"],
+      ["ableton/README.md", 2095, "2372e71f8e5fc05d8c4c3d609388e8a3a7390901d1af27eb897a018d8c29720c"],
+      ["ableton/insert_audio.py", 7718, "439ec109d31c35c4da488e43b8593c315f2a0925d712538e0e813a5e565fd68d"],
+      ["benchmark.sh", 1515, "1ca7b070f6272b3814214025d3d33849d3f0c12f2cf42ee830c2a3ea82db1aa5"],
+      ["bootstrap.sh", 8812, "d05fa7f5849de1f2f8a31462e4bba174d3fdddcbd7ecd4bbbff3c0bc12199b44"],
+      ["install.sh", 6509, "ca6b0af0325a9f6f43b5f2e6aec19fcba82e035b4dc55c74600fc43c38c027ec"],
+      ["models/__init__.py", 0, "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"],
+      ["models/defs/__init__.py", 0, "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"],
+      ["models/defs/audio_encoding.py", 9380, "f31aa0026d5292adfa6eab288d076747fd04200d829de2defdc751a974d0d784"],
+      ["models/defs/demo_mlx.py", 12751, "dfa7ec9ec4820538e95913a51409da060b7202ffee30eb2ac993acc335d305df"],
+      ["models/defs/dit_mlx.py", 13470, "7a57f7140c1c2ecde477c1029770f05adf1b77f8dd876a1231c5255da509e75a"],
+      ["models/defs/dit_mlx_medium.py", 17685, "12f4e0743f0c00f010f7e6b962e1de921378d1f4b3a3b77e6f106ece15e3ee4a"],
+      ["models/defs/latent_dataset.py", 14908, "8be23c873273f42167069321fd69751e33187bd779669d2c2e75a2b1a17f7177"],
+      ["models/defs/lora.py", 52582, "85464d21291d8ba8d9b1d281260ededc926d7fe91271945c7611cdef46fb30a0"],
+      ["models/defs/lora_merge.py", 40136, "5a1738c078b088b367c24d7d7c12ab3a99b09e5c703ac9a5c343b5de4c121758"],
+      ["models/defs/sa3_pipeline.py", 10775, "e8aca5225eeda40e1d3f53c04968bbce9df6290021f4bdc5c1a67d6d68013de8"],
+      ["models/defs/same_l_decoder.py", 12795, "c9c4922169423407ee6acbf6e7c88a46761d75cacecdac4de24d4a484e762622"],
+      ["models/defs/same_l_encoder.py", 5720, "71338711802fb5c7aaf15fea3852110c0a828cdbe94c643c553d4332944c5722"],
+      ["models/defs/same_s_decoder.py", 11002, "2733dc254a67c133489108616652f353aec21566e900169b15d8d871ec57c88c"],
+      ["models/defs/same_s_encoder.py", 7168, "d6785bb4ed549158d7dd2a3a13b85c2ec9cccf7f6ff05e9af58120ebbfd3e1df"],
+      ["models/defs/t5gemma_mlx.py", 13913, "ec8f9c088c72174c75aabf9e54ce410d53ff306244ccd397657ac961683a11e3"],
+      ["models/defs/training.py", 7674, "9bf99e2019fab90d75dd8caac8988e4ae723e3bc47fca137cab56025d705faa8"],
+      ["requirements-gradio.txt", 170, "f1f4a2b95c58fc80b7881e7ee9bee98f9e565f2be58ccee63d53d5e4a8ccb896"],
+      ["requirements.txt", 547, "c173edcf798d31b2b4c9dc919e439de3dc7c915d82a3f4255b62a4dae516b8ad"],
+      ["sa3", 3108, "ff5411de89df7fdb986419ec441d57f0dd9856f89821aef48f8fd21fe1f1656b"],
+      ["sa3-gradio", 1247, "86cf132971ee880892cf68687201a0f2a3d3e9ed8fbb4c5d6c61a7d433cc8aa7"],
+      ["scripts/benchmark.py", 7201, "91c76adbfba3dadfb80fd32a3bd751be95a2b01f02a7939d3d849cbc70086715"],
+      ["scripts/examples.py", 6672, "011f05d5a690b2f46a7b8a0b898a4d94aa130205a121d12dfbdd18c6c8506213"],
+      ["scripts/export_base_npz.py", 4108, "0ef788a8ef9c679d2e8b8bb18ded0a2f775c7781df84d4dd73542971f46f62b1"],
+      ["scripts/install.py", 6082, "7f629fccec01fd88ae159bae3495299f04be205733916851ea5b0138d851a1a8"],
+      ["scripts/lora_train_mlx.py", 49794, "e5d87e10e122ff4a054ac7f0d261650830e5d77b7a9fa2a07a14452db4cfae60"],
+      ["scripts/parity_forward_mlx.py", 4918, "a736a3a29ea0dcccf36543e8e9f63c38b1c1bef670a51c67915b7473c665e8f1"],
+      ["scripts/parity_forward_torch.py", 5236, "54db7fca02a5ce618417ee52ec54d3d291d866ff67762e4fc2e95371f9af201b"],
+      ["scripts/pre_encode_mlx.py", 15985, "f6e4a2c7bcec19b0e9fc4316ee31b2277663a7dc0e569eb76400b44457686729"],
+      ["scripts/sa3_gradio.py", 69093, "72c6eafa087dd309151cc4524c93a9281c3f3bdde9580a5578458bce047a59fd"],
+      ["scripts/sa3_mlx.py", 45778, "312c2833fac5ca270cbeebe7037b3fbeacd87b10c9b5d057587c5eaf824fb951"],
+      ["scripts/spec.py", 6574, "3e85ee7850a4e3861733823c1c712a123550c48c1cbd47cbb0e0baea2f31b42d"],
+      ["scripts/test_all_configs.py", 9969, "db210dfb7297c640feaede146a9538b1da6ea167436c04f8921c741f472d37de"],
+      ["scripts/test_lora_merge.py", 20704, "efd88ade4205e53bf938135853e2c9cd53a61cccc844bc6f17dfb77409c8d36f"],
+      ["scripts/weights.py", 7303, "9b367084a8cfa6dffa090bf39e84f850981f689e43aab78112787fdcb3d16bf0"],
+    ]),
+  }),
+  // The Python and the packages that run on the Mac it was tested on; Pillow is only for training.
+  python: Object.freeze({
+    version: "3.11.14",
+    packages: Object.freeze([
+      "anyio==4.15.1", "cffi==2.1.1", "click==8.5.0", "filelock==4.2.4", "fsspec==2026.9.0", "h11==0.16.0",
+      "hf-xet==1.7.0", "httpcore2==2.16.0", "httpx2==2.16.0", "huggingface-hub==2.3.0", "idna==3.20",
+      "mlx==0.32.4", "mlx-metal==0.32.4", "numpy==2.4.6", "packaging==26.3", "pycparser==3.12", "pyyaml==6.0.3",
+      "sentencepiece==0.2.2", "soundfile==0.14.0", "tqdm==4.70.1", "truststore==0.10.5", "typing-extensions==4.16.0",
+    ]),
+  }),
+  // Stability AI's weights (Stability AI Community License; T5Gemma under the Gemma Terms of Use).
+  weights: Object.freeze({
+    url: (name) => `https://huggingface.co/stabilityai/stable-audio-3-optimized/resolve/${HF_SNAPSHOT}/MLX/${name}`,
+    files: Object.freeze({
+      "t5gemma_f16.npz": Object.freeze({ size: 567_443_068, sha256: "8deb20489f36d9aec539f26c9c67321f99bc5fe300d470435ed6e76be4f16bbd" }),
+      "dit_medium_f16.npz": Object.freeze({ size: 2_907_300_946, sha256: "f9e5647ea3225818657d47d47ae4b34afa29c0568206ca89566c1a758944a38e" }),
+      "same_l_decoder_f32.npz": Object.freeze({ size: 1_704_311_976, sha256: "84924be2122d3a20fce443f40b782d9cd88e8e73707476326003ac47659a2287" }),
+      "dit_sm-music_f16.npz": Object.freeze({ size: 919_193_814, sha256: "8ed3f38e2597f361ee675051f1265d9aa2ae2fffce1c61acd2e9fe31e1db1cbc" }),
+      "same_s_decoder_f32.npz": Object.freeze({ size: 218_090_820, sha256: "909928a8e6937c1ebe6ac4b729f0462bd3773704a11ea18278e42671dc69bfe4" }),
+    }),
+  }),
+  // What the listener agrees to before the first download.
+  licenses: Object.freeze([
+    Object.freeze({ id: "stability-ai-community", name: "Stability AI Community License", url: "https://stability.ai/license" }),
+    Object.freeze({ id: "gemma-terms", name: "Gemma Terms of Use", url: "https://huggingface.co/stabilityai/stable-audio-3-optimized/blob/main/LICENSE_GEMMA.md" }),
+  ]),
+});

package/src/integrations/web/deepseek-web.mjs

@@ -69,7 +69,7 @@ export function createDeepSeekWebResearch({ apiKey, fetch: fetchImpl = globalThi
     if (status !== 200) throw serviceError(status, body);
     const title = typeof body.title === "string" && body.title.trim() ? clip(body.title.trim(), 300) : url;
     return webResult({ provider: "deepseek", kind: "read", status: "found", retrievedAt,
-      summary: clip(text, webLimits.textChars), truncated: text.length > webLimits.textChars,
+      summary: clip(text, webLimits.fullTextChars), truncated: text.length > webLimits.fullTextChars,
       sources: [{ title, url, snippet: "", published_at: null }] });
   }
 

package/src/integrations/web/web-research.mjs

@@ -1,3 +1,4 @@
+import { readModelRoles } from "../../runtime/pi/model-roles.mjs";
 import { createPersistentCredentialStore } from "../../runtime/pi/persistent-credential-store.mjs";
 import { createBraveWebResearch } from "./brave-web.mjs";
 import { createCodexWebResearch } from "./codex-web.mjs";
@@ -5,8 +6,13 @@ import { createDeepSeekWebResearch } from "./deepseek-web.mjs";
 import { failure, webProviderName } from "./web-result.mjs";
 
 // Search goes to the first backend that is set up; reading needs a backend that can open pages.
-// MOONDOG_WEB_SEARCH_PROVIDER and MOONDOG_WEB_READ_PROVIDER pick one instead.
+// The web search role in Settings (model-roles.json) picks one instead, and MOONDOG_WEB_SEARCH_PROVIDER
+// and MOONDOG_WEB_READ_PROVIDER pick over that. As in Hermes Agent, a call that fails on the chosen
+// backend is tried once more on each other backend that is set up, so one service being down or out
+// of credit doesn't leave the agent without the web.
 const order = Object.freeze({ search: ["deepseek", "brave", "codex"], read: ["deepseek", "codex"] });
+// Failures that another backend would only repeat.
+const final = new Set(["web_cancelled", "web_input_invalid", "web_url_invalid"]);
 const providerIds = Object.freeze({ deepseek: "deepseek", brave: "brave", codex: "codex_cli" });
 const keys = Object.freeze({
   deepseek: { credential: "deepseek", variable: "DEEPSEEK_API_KEY" },
@@ -33,43 +39,103 @@ export async function createWebResearch({
   credentials = createPersistentCredentialStore(environment),
   fetch = globalThis.fetch,
   createCodex = createCodexWebResearch,
+  readRoles = readModelRoles,
   now,
 } = {}) {
-  let current = { backends: {}, choices: {} };
+  let current = { backends: {}, choices: {}, found: {} };
+
+  // A backend whose key did not change keeps its cache. A working Codex stays; one that was not ready
+  // is checked again, since the listener may have signed in since.
+  async function backendFor(name, found, previous) {
+    if (name === "codex") {
+      const kept = previous?.backends.codex;
+      return kept?.publicStatus().state === "configured" ? kept : createCodex({ environment, now });
+    }
+    const kept = previous?.backends[name] && previous.found[name]?.key === found[name]?.key;
+    return kept ? previous.backends[name] : { deepseek: createDeepSeekWebResearch, brave: createBraveWebResearch }[name]({ apiKey: found[name]?.key, fetch, now });
+  }
 
   async function load(previous) {
     const found = {
       deepseek: await readKey(credentials, environment, keys.deepseek),
       brave: await readKey(credentials, environment, keys.brave),
     };
+    const role = (await readRoles(environment).catch(() => ({}))).web_search?.service ?? null;
     const choices = {};
     for (const kind of ["search", "read"]) {
       const wanted = environment[`MOONDOG_WEB_${kind.toUpperCase()}_PROVIDER`]?.trim().toLowerCase();
-      if (wanted) choices[kind] = order[kind].includes(wanted) ? { name: wanted, override: true } : { name: null, reason: "web_provider_unknown", wanted };
+      if (wanted) choices[kind] = order[kind].includes(wanted) ? { name: wanted, selectedBy: `MOONDOG_WEB_${kind.toUpperCase()}_PROVIDER` } : { name: null, reason: "web_provider_unknown", wanted };
+      // Brave only searches, so with Brave chosen a read still goes to the first backend that can.
+      else if (role && order[kind].includes(role)) choices[kind] = { name: role, selectedBy: "settings" };
       else choices[kind] = { name: order[kind].find((name) => name !== "codex" && found[name]) ?? "codex" };
     }
     const backends = {};
     for (const name of new Set(Object.values(choices).map((choice) => choice.name).filter(Boolean))) {
-      // A backend whose key did not change keeps its cache.
-      const create = { deepseek: createDeepSeekWebResearch, brave: createBraveWebResearch }[name];
-      if (create) {
-        const kept = previous?.backends[name] && previous.found[name]?.key === found[name]?.key;
-        backends[name] = kept ? previous.backends[name] : create({ apiKey: found[name]?.key, fetch, now });
-      }
-      // A working Codex stays; one that was not ready is checked again, since the listener may have signed in since.
-      if (name === "codex") {
-        const kept = previous?.backends.codex;
-        backends.codex = kept?.publicStatus().state === "configured" ? kept : await createCodex({ environment, now });
-      }
+      backends[name] = await backendFor(name, found, previous);
     }
     return { backends, choices, found };
   }
 
+  // The other backends a failed call can go to: ones with a key, and Codex once it is signed in.
+  async function alternatives(kind, tried) {
+    const names = [];
+    for (const name of order[kind]) {
+      if (name === tried) continue;
+      if (name !== "codex" && !current.found[name]) continue;
+      current.backends[name] ??= await backendFor(name, current.found, null);
+      if (name === "codex" && current.backends.codex.publicStatus().state !== "configured") continue;
+      names.push(name);
+    }
+    return names;
+  }
+
+  async function research(kind, input, options) {
+    const first = backend(kind);
+    const name = current.choices[kind].name;
+    let failed;
+    try {
+      const result = await first[kind](input, options);
+      // A page the chosen backend could not read may open on another.
+      if (kind === "search" || result.status !== "unavailable") return result;
+      failed = result;
+    } catch (error) {
+      if (final.has(error?.code) || options?.signal?.aborted) throw error;
+      failed = error;
+    }
+    for (const other of await alternatives(kind, name)) {
+      try {
+        const result = await current.backends[other][kind](input, options);
+        if (kind === "search" || result.status !== "unavailable") return { ...result, fallback_from: providerIds[name] };
+      } catch (error) {
+        if (final.has(error?.code) || options?.signal?.aborted) throw error;
+      }
+    }
+    if (failed instanceof Error) throw failed;
+    return failed;
+  }
+
+  /** Each service, whether it is set up for each operation, and which one the role chose; for Settings. */
+  async function services() {
+    const role = (await readRoles(environment).catch(() => ({}))).web_search?.service ?? null;
+    current.backends.codex ??= await backendFor("codex", current.found, null);
+    const codex = current.backends.codex.publicStatus().state === "configured";
+    return {
+      chosen: role,
+      search: operationStatus("search"),
+      read: operationStatus("read"),
+      services: order.search.map((name) => {
+        const ready = name === "codex" ? codex : Boolean(current.found[name]);
+        return { id: name, provider: providerIds[name], name: webProviderName(providerIds[name]), ready,
+          search: ready, read: ready && order.read.includes(name) };
+      }),
+    };
+  }
+
   function operationStatus(kind) {
     const choice = current.choices[kind];
     if (!choice?.name) return { provider: null, state: "unavailable", reason: choice?.reason ?? "web_provider_unknown", ...(choice?.wanted ? { requested: choice.wanted } : {}) };
     const provider = providerIds[choice.name];
-    const override = choice.override ? { selected_by: `MOONDOG_WEB_${kind.toUpperCase()}_PROVIDER` } : {};
+    const override = choice.selectedBy ? { selected_by: choice.selectedBy } : {};
     if (choice.name === "codex") {
       const codex = current.backends.codex.publicStatus();
       return { provider, state: codex.state, ...(codex.reason ? { reason: codex.reason } : {}), ...override };
@@ -103,8 +169,9 @@ export async function createWebResearch({
   current = await load();
   return {
     publicStatus,
-    search: async (input, options) => backend("search").search(input, options),
-    read: async (input, options) => backend("read").read(input, options),
+    services,
+    search: (input, options) => research("search", input, options),
+    read: (input, options) => research("read", input, options),
     /** Reads keys and settings again, after /auth or /reload. */
     async refresh() {
       const previous = current;

package/src/integrations/web/web-result.mjs

@@ -4,8 +4,12 @@ import Ajv from "ajv";
 
 // Every web backend returns this one result shape, checked by the same rules,
 // so the agent and the screen never need to know which service answered.
+// After Hermes Agent's web tools: a search gives five sources unless the agent asks for up to ten,
+// and a read keeps the page's whole text, handing it out a window at a time; the agent asks for the
+// next window with next_offset instead of losing everything past the first.
 export const webLimits = Object.freeze({
-  sources: 5, snippetChars: 800, textChars: 12_000, cacheMs: 300_000, cacheEntries: 32, responseBytes: 2_000_000,
+  sources: 5, maxSources: 10, snippetChars: 1200, textChars: 15_000, fullTextChars: 200_000,
+  cacheMs: 300_000, cacheEntries: 32, responseBytes: 2_000_000,
 });
 
 // What each backend's text is, so the agent can tell a search engine's snippet from a model's summary.
@@ -19,13 +23,14 @@ export function webProviderName(provider) {
   return backends[provider]?.name ?? null;
 }
 
-const resultSchema = {
+// A backend's result holds a page's whole text; the agent's holds one window of it.
+const resultSchema = (textChars) => ({
   type: "object", additionalProperties: false,
   properties: {
     status: { type: "string", enum: ["found", "not_found", "unavailable"] },
-    summary: { type: "string", maxLength: webLimits.textChars },
+    summary: { type: "string", maxLength: textChars },
     sources: {
-      type: "array", maxItems: webLimits.sources,
+      type: "array", maxItems: webLimits.maxSources,
       items: {
         type: "object", additionalProperties: false,
         properties: {
@@ -39,8 +44,11 @@ const resultSchema = {
     },
   },
   required: ["status", "summary", "sources"],
-};
-const validate = new Ajv({ strict: false }).compile(resultSchema);
+});
+const ajv = new Ajv({ strict: false });
+const validate = ajv.compile(resultSchema(webLimits.fullTextChars));
+const validateWindow = ajv.compile(resultSchema(webLimits.textChars));
+const offsetOf = (value) => (Number.isInteger(value) && value >= 0 ? value : null);
 
 export function failure(code, message) {
   return Object.assign(new Error(message), { code });
@@ -101,7 +109,7 @@ export function webResult({ provider, kind, status, summary = "", sources = [],
 export function projectWebResearchResult(value) {
   const payload = { status: value?.status, summary: value?.summary, sources: value?.sources };
   const backend = backends[value?.provider];
-  if (!validate(payload) || (payload.status === "found" && !payload.sources.length) ||
+  if (!validateWindow(payload) || (payload.status === "found" && !payload.sources.length) ||
       !backend?.content[value.kind] || value.evidence !== backend.evidence || !Number.isFinite(Date.parse(value.retrieved_at))) {
     throw failure("web_output_invalid", `${backend?.name ?? "The web service"} returned an invalid or unsourced research result.`);
   }
@@ -110,6 +118,9 @@ export function projectWebResearchResult(value) {
     retrieved_at: new Date(value.retrieved_at).toISOString(), from_cache: value.from_cache === true,
     content_kind: backend.content[value.kind], trust: "untrusted_web_content", evidence: backend.evidence,
     ...(value.truncated === true ? { truncated: true } : {}),
+    ...(value.kind === "read" && offsetOf(value.total_chars) !== null ? {
+      text_offset: offsetOf(value.text_offset) ?? 0, total_chars: value.total_chars, next_offset: offsetOf(value.next_offset),
+    } : {}),
     summary: cleanText(payload.summary), sources: projectSources(payload.sources),
   };
 }
@@ -131,14 +142,46 @@ export function searchSources(items) {
     if (snippet) seen.add(snippet);
     const date = typeof item.published_at === "string" ? cleanText(item.published_at).slice(0, 100) : "";
     sources.push({ title, url, snippet, published_at: date || null });
-    if (sources.length === webLimits.sources) break;
+    if (sources.length === webLimits.maxSources) break;
   }
   return sources;
 }
 
+// One window of a page's text, ending at a line or word break near the limit when there is one.
+function textWindow(text, offset) {
+  let end = Math.min(text.length, offset + webLimits.textChars);
+  if (end < text.length) {
+    const floor = offset + Math.floor(webLimits.textChars * 0.8);
+    const lineBreak = text.lastIndexOf("\n", end);
+    const space = text.lastIndexOf(" ", end);
+    end = lineBreak > floor ? lineBreak : space > floor ? space : end;
+  }
+  return { summary: text.slice(offset, end), end };
+}
+
+/** What one call asked for: up to `limit` sources of a search, or the window of a read from `offset`. */
+function windowed(result, kind, { limit, offset }) {
+  if (kind === "search") return { ...result, sources: result.sources.slice(0, limit) };
+  const text = result.summary;
+  if (offset > 0 && offset >= text.length) {
+    throw failure("web_input_invalid", `The page has ${text.length} characters, so offset ${offset} is past its end.`);
+  }
+  const { summary, end } = textWindow(text, offset);
+  const more = end < text.length;
+  return { ...result, summary, text_offset: offset, total_chars: text.length, next_offset: more ? end : null,
+    ...(more || result.truncated ? { truncated: true } : {}) };
+}
+
+function integerIn(value, minimum, maximum, fallback, message) {
+  if (value === undefined) return fallback;
+  if (!Number.isInteger(value) || value < minimum || value > maximum) throw failure("web_input_invalid", message);
+  return value;
+}
+
 /**
  * The parts every backend shares: one query or URL in, a cancellable request,
- * and a five-minute process-local cache of found results.
+ * and a five-minute process-local cache of found results. The cache keeps the whole result, so a
+ * smaller limit or a later window of the same page needs no second request.
  */
 export function createWebOperations({ unavailable = () => null, queryChars = 500, run, now = () => new Date() }) {
   const cache = new Map();
@@ -146,9 +189,14 @@ export function createWebOperations({ unavailable = () => null, queryChars = 500
   async function research(kind, input, { signal } = {}) {
     const blocked = unavailable(kind);
     if (blocked) throw blocked;
-    if (!input || typeof input !== "object" || Object.keys(input).some((key) => key !== (kind === "search" ? "query" : "url"))) {
+    const allowed = kind === "search" ? ["query", "limit"] : ["url", "offset"];
+    if (!input || typeof input !== "object" || Object.keys(input).some((key) => !allowed.includes(key))) {
       throw failure("web_input_invalid", "Supply one search query or public URL.");
     }
+    const view = {
+      limit: integerIn(input.limit, 1, webLimits.maxSources, webLimits.sources, `Ask for 1 to ${webLimits.maxSources} search results.`),
+      offset: integerIn(input.offset, 0, webLimits.fullTextChars, 0, "The offset must be a whole number of characters, from 0."),
+    };
     const value = kind === "read" ? publicWebUrl(input.url) : typeof input.query === "string" ? input.query.trim() : input.query;
     if (typeof value !== "string" || !value) throw failure("web_input_invalid", "The web query or URL is empty.");
     if (value.length > (kind === "search" ? queryChars : 2048)) {
@@ -158,7 +206,7 @@ export function createWebOperations({ unavailable = () => null, queryChars = 500
     const key = `${kind}:${value}`;
     const cached = cache.get(key);
     if (cached && now().getTime() - Date.parse(cached.retrieved_at) < webLimits.cacheMs) {
-      return { ...structuredClone(cached), from_cache: true };
+      return windowed({ ...structuredClone(cached), from_cache: true }, kind, view);
     }
     const controller = new AbortController();
     active.add(controller);
@@ -168,7 +216,7 @@ export function createWebOperations({ unavailable = () => null, queryChars = 500
         cache.set(key, result);
         if (cache.size > webLimits.cacheEntries) cache.delete(cache.keys().next().value);
       }
-      return structuredClone(result);
+      return windowed(structuredClone(result), kind, view);
     } finally {
       active.delete(controller);
     }

package/src/profile/listening-history-store.mjs

@@ -386,7 +386,7 @@ function normalizedProfileInput(value, batch) {
       record.provenance.source_kind !== "import" ||
       !(record.provenance.source_system === "spotify_account_data" ||
         (record.provenance.source_system === "spotify_web_api" && profileImport.source_key === "spotify.web_api_library") ||
-        (["youtube_music", "qq_music", "netease", "lastfm"].includes(record.provenance.source_system) &&
+        (["youtube_music", "qq_music", "netease", "lastfm", "spotify_playlist", "apple_music_playlist"].includes(record.provenance.source_system) &&
           profileImport.source_key === `${record.provenance.source_system}.music_import`)) ||
       !profileImport.member_names.includes(record.provenance.source_member) ||
       record.provenance.profile_import_id?.toLowerCase() !== profileImportId ||
@@ -844,6 +844,7 @@ export class ListeningHistoryStore {
   #coverageSources = null;
   #evidence = null;
   #ledgerChanges = 0;
+  #listeningDays = null;
 
   constructor(database) {
     this.#database = database;
@@ -2058,6 +2059,59 @@ export class ListeningHistoryStore {
       ...(started.length ? { moondog_started_plays: started.length } : {}), top_artists: artists });
   }
 
+  // The listener's own plays a local day at a time, for the window's taste record: every day's plays, the
+  // same for the most played artists, and the plays Moondog started, kept apart as recentAttention keeps
+  // them. Counts and artist names only. Kept until the stored plays change, since a long history is many rows.
+  listeningDays({ subjectId, artists = 8 } = {}) {
+    if (this.#closed) throw new Error("Listening history store is closed");
+    if (!isUuid(subjectId)) throw new TypeError("A valid profile subject is required");
+    if (!Number.isSafeInteger(artists) || artists < 0 || artists > 20) throw new TypeError("Artist count is invalid");
+    const subject = subjectId.toLowerCase();
+    const version = `${this.listeningDataVersion()}:${subject}:${artists}`;
+    if (this.#listeningDays?.version === version) return structuredClone(this.#listeningDays.value);
+    const effective = `e.subject_id = ?
+      AND NOT EXISTS (SELECT 1 FROM listening_event_supersessions s WHERE s.superseded_event_id = e.listening_event_id)
+      AND NOT EXISTS (SELECT 1 FROM listening_event_mirrors m WHERE m.mirror_event_id = e.listening_event_id)`;
+    const suggestions = this.#suggestionsForMatching();
+    const since = suggestions.length ? new Date(Date.parse(suggestions[0].requested_at) - SUGGESTION_WINDOW.beforeMs).toISOString() : null;
+    const started = !since ? [] : markMoondogStartedPlays(this.#database.prepare(`SELECT
+      e.listening_event_id, e.record_json AS event_json, t.record_json AS track_json FROM listening_events e
+      JOIN track_refs t ON t.track_ref_id = e.track_ref_id AND t.revision = e.track_ref_revision
+      WHERE ${effective} AND e.occurred_at >= ?`)
+      .all(subject, since).map((row) => ({ id: row.listening_event_id, event: JSON.parse(row.event_json), track: JSON.parse(row.track_json) })),
+    suggestions).rows.filter((row) => row.moondog_suggestion_id).map((row) => row.id);
+    const own = `${effective} AND e.listening_event_id NOT IN (SELECT value FROM json_each(?))`;
+    const left = JSON.stringify(started);
+    const pairs = (rows) => rows.map((row) => [row.day, row.plays]);
+    const days = this.#database.prepare(`SELECT date(e.occurred_at, 'localtime') AS day, COUNT(*) AS plays
+      FROM listening_events e WHERE ${own} GROUP BY day ORDER BY day`).all(subject, left);
+    let value = null;
+    if (days.length) {
+      const credited = `FROM listening_events e
+        JOIN track_refs t ON t.track_ref_id = e.track_ref_id AND t.revision = e.track_ref_revision
+        JOIN json_each(t.record_json, '$.artist_credits') a
+        WHERE ${own} AND json_extract(a.value, '$.name') IS NOT NULL`;
+      const top = artists === 0 ? [] : this.#database.prepare(`SELECT json_extract(a.value, '$.name') AS name, COUNT(*) AS plays
+        ${credited} GROUP BY name ORDER BY plays DESC, name LIMIT ?`).all(subject, left, artists);
+      const byArtist = new Map(top.map((row) => [row.name, []]));
+      if (top.length) {
+        for (const row of this.#database.prepare(`SELECT json_extract(a.value, '$.name') AS name,
+          date(e.occurred_at, 'localtime') AS day, COUNT(*) AS plays
+          ${credited} AND json_extract(a.value, '$.name') IN (SELECT value FROM json_each(?))
+          GROUP BY name, day ORDER BY day`).iterate(subject, left, JSON.stringify(top.map((artist) => artist.name)))) {
+          byArtist.get(row.name)?.push([row.day, row.plays]);
+        }
+      }
+      const moondog = started.length ? this.#database.prepare(`SELECT date(occurred_at, 'localtime') AS day, COUNT(*) AS plays
+        FROM listening_events WHERE listening_event_id IN (SELECT value FROM json_each(?)) GROUP BY day ORDER BY day`).all(left) : [];
+      value = { first_day: days[0].day, last_day: days.at(-1).day, days: pairs(days),
+        artists: top.map((artist) => ({ name: artist.name, plays: artist.plays, days: byArtist.get(artist.name) })),
+        moondog_days: pairs(moondog) };
+    }
+    this.#listeningDays = { version, value };
+    return structuredClone(value);
+  }
+
   // Which spans of time the stored plays cover, and where plays may be missing.
   listeningCoverage({ subjectId } = {}) {
     if (this.#closed) throw new Error("Listening history store is closed");

package/src/profile/listening-profile-projection.mjs

@@ -1616,7 +1616,7 @@ function persistedExplanation(record) {
     library_artist_followed: `The artist appears in the followed-artists snapshot captured at ${record.provenance.captured_at}.`,
     library_track_banned: `The track appears in the explicitly banned-tracks snapshot captured at ${record.provenance.captured_at}.`,
     library_artist_banned: `The artist appears in the explicitly banned-artists snapshot captured at ${record.provenance.captured_at}.`,
-    playlist_track_added: `The track appears in the ${provider} playlist named ${JSON.stringify(attributes.playlist_name)} at position ${attributes.playlist_position}.` + (attributes.selected_public_playlist ? " You selected this public playlist; ownership and listening are not established." : ""),
+    playlist_track_added: `The track appears in the ${provider} playlist named ${JSON.stringify(attributes.playlist_name)} at position ${attributes.playlist_position}.` + (attributes.listener_made ? " You made this playlist; listening is not established." : attributes.selected_public_playlist ? " You selected this public playlist; ownership and listening are not established." : ""),
     search_result_interacted: `A Spotify search for ${JSON.stringify(label)} led to an interaction with a ${attributes.result_entity_type} result at ${record.observed_at}.`,
     wrapped_track_ranked: `Spotify Wrapped ranked this track at position ${attributes.rank} for ${attributes.period}.`,
     wrapped_artist_ranked: `Spotify Wrapped ranked this artist at position ${attributes.rank} for ${attributes.period}.`,

package/src/profile/music-import-bundle.mjs

@@ -58,7 +58,9 @@ export function prepareMusicBundle({ provider, subjectId, capturedAt, rows, dige
           label: title, ...(artist ? { artist_credit: artist } : {}), ...(album ? { release: album } : {}) },
         observed_at: capturedAt,
         attributes: row.playlistId ? { playlist_name: musicText(row.playlistName) || "Selected playlist",
-          playlist_position: row.position ?? 1, playlist_id: String(row.playlistId), selected_public_playlist: true } : {},
+          playlist_position: row.position ?? 1, playlist_id: String(row.playlistId),
+          // A playlist the service says the listener made is theirs; any other one is only one they chose.
+          ...(row.listenerMade === true ? { listener_made: true } : { selected_public_playlist: true }) } : {},
         provenance: { source_kind: "import", source_system: provider, source_member: row.member,
           profile_import_id: profileId, captured_at: capturedAt },
       });

package/src/profile/music-providers.mjs

@@ -5,6 +5,9 @@ export const MUSIC_PROVIDER_LABELS = Object.freeze({
   lastfm: "Last.fm",
   qq_music: "QQ Music",
   netease: "NetEase Music",
+  // Playlists the listener imported into the library by their links.
+  spotify_playlist: "Spotify",
+  apple_music_playlist: "Apple Music",
 });
 
 export function musicProviderLabel(system) {

package/src/profile/taste-compiler.mjs

@@ -136,14 +136,23 @@ export function compileTaste(requested, context) {
   const usable = kept.some((descriptor) => ["genre", "instrument", "mood", "texture"].includes(descriptor.facet));
   const bpm = Number.isInteger(requested?.bpm) && requested.bpm >= BPM_RANGE.min && requested.bpm <= BPM_RANGE.max ? requested.bpm : null;
   const bpmSource = bpm && ["request", "moment", "reading"].includes(requested?.bpm_source) ? requested.bpm_source : bpm ? "moondog" : null;
-  return { usable, descriptors: kept, dropped, bpm, ...(bpm ? { bpm_source: bpmSource } : {}), title: trackTitle(requested?.title, kept, names) };
+  return { usable, descriptors: kept, dropped, bpm, ...(bpm ? { bpm_source: bpmSource } : {}), title: trackTitle(requested?.title, kept, names), names };
 }
 
-// Moondog names its own records. A proposed title stays when it is short, plain and names no one;
-// otherwise the title is the sound in a few words.
-function trackTitle(proposed, descriptors, names) {
+/**
+ * A name Moondog may give its own record: short, plain, naming no one (names is what compileTaste
+ * returned) and asking for no singing. Returns the tidied name, or null.
+ */
+export function acceptableRecordTitle(proposed, names = {}) {
   const title = clean(proposed);
-  if (title && Array.from(title).length <= 60 && TITLE_SHAPE.test(title) && !namedBy(title, names) && !VOCAL_WORDS.test(title)) return title;
+  return title && Array.from(title).length <= 60 && TITLE_SHAPE.test(title) && !namedBy(title, names) && !VOCAL_WORDS.test(title) ? title : null;
+}
+
+// Moondog names its own records. A proposed title stays when it is acceptable; otherwise the title
+// is the sound in a few words.
+function trackTitle(proposed, descriptors, names) {
+  const title = acceptableRecordTitle(proposed, names);
+  if (title) return title;
   const pick = (facets) => descriptors.find((descriptor) => facets.includes(descriptor.facet))?.term;
   const words = [pick(["mood"]) ?? pick(["texture"]), pick(["genre"]) ?? pick(["instrument"])].filter(Boolean);
   const text = [...new Set(words)].join(" ");