@audiofool/moondog 0.2.1 → 0.3.0-beta.1

package/NOTICE

@@ -0,0 +1,12 @@
+Moondog
+Copyright 2026 Audiofool.
+
+Moondog can make music with Stable Audio 3 by Stability AI.
+Listeners install Stable Audio 3 and its weights on their own Mac; Moondog does not include them.
+
+This Stability AI Model is licensed under the Stability AI Community License, Copyright ©  Stability AI Ltd. All Rights Reserved
+
+A copy of the Stability AI Community License is in licenses/stability-ai-community-license.md.
+
+Stable Audio 3 uses the T5Gemma text encoder.
+Gemma is provided under and subject to the Gemma Terms of Use found at ai.google.dev/gemma/terms

package/README.md

@@ -4,7 +4,7 @@
 
 <h1 align="center">Moondog</h1>
 
-<p align="center">Version 0.2.1</p>
+<p align="center">Source candidate 0.3.0-beta.1</p>
 
 <p align="center"><strong>A listening room that shows its work.</strong></p>
 
@@ -33,7 +33,7 @@ npm ci
 npm start
 ```
 
-[@audiofool/moondog](https://www.npmjs.com/package/@audiofool/moondog) 0.2.0 is the published package; `npm install --global @audiofool/moondog` installs it.
+[@audiofool/moondog](https://www.npmjs.com/package/@audiofool/moondog) 0.2.2 is the published package; `npm install --global @audiofool/moondog` installs it.
 To see the agent work through fictional data, with no sign-in at all, run `npm run demo` from the checkout.
 
 The source version supports `moondog update` and `/update`, with stable (`latest`) and preview (`beta`) channels.
@@ -212,3 +212,4 @@ Your profile, and anything Moondog remembers, carry over.
 
 Moondog is open source under the [Apache License 2.0](LICENSE).
 Copyright 2026 Audiofool.
+Music making runs Stable Audio 3, which you install yourself; [NOTICE](NOTICE) holds its attribution, and [licenses/](licenses/stability-ai-community-license.md) holds the Stability AI Community License.

package/licenses/stability-ai-community-license.md

@@ -0,0 +1,58 @@
+STABILITY AI COMMUNITY LICENSE AGREEMENT
+	
+Last Updated: July 5, 2024
+
+1. INTRODUCTION
+
+This Agreement applies to any individual person or entity (“You”, “Your” or “Licensee”) that uses or distributes any portion or element of the Stability AI Materials  or Derivative Works thereof for any Research & Non-Commercial or Commercial purpose. Capitalized terms not otherwise defined herein are defined in Section V below.
+
+This Agreement is intended to allow research, non-commercial, and limited commercial uses of the Models free of charge. In order to ensure that certain limited commercial uses of the Models continue to be allowed, this Agreement  preserves free access to the Models for people or organizations  generating annual revenue of less than US $1,000,000 (or local currency equivalent).  
+
+By clicking “I Accept”  or by using or distributing or using any portion or element of the Stability Materials or Derivative Works, You agree that You have read, understood and are bound by the terms of this Agreement. If You are acting on behalf of a company, organization or other entity, then “You” includes you and that entity, and You agree that You: (i) are an authorized representative of such entity with the authority to bind such entity to this Agreement, and (ii) You agree to the terms of this Agreement on that entity’s behalf. 
+
+2. RESEARCH & NON-COMMERCIAL USE LICENSE
+
+Subject to the terms of this Agreement, Stability AI grants You a non-exclusive, worldwide, non-transferable, non-sublicensable, revocable and royalty-free limited license under Stability AI’s intellectual property or other rights owned by Stability AI embodied in the Stability AI Materials to use, reproduce, distribute, and create Derivative Works of, and make modifications to, the Stability AI Materials for any Research or Non-Commercial Purpose. “Research Purpose” means academic or scientific advancement, and in each case, is not primarily intended for commercial advantage or monetary compensation to You or others. “Non-Commercial Purpose” means any purpose other than a Research Purpose that is not primarily intended for commercial advantage or monetary compensation to You or others, such as personal use (i.e., hobbyist) or evaluation and testing.  
+
+3. COMMERCIAL USE LICENSE
+
+Subject to the terms of this Agreement (including the remainder of this Section III), Stability AI grants You a non-exclusive, worldwide, non-transferable, non-sublicensable, revocable and royalty-free limited license under Stability AI’s intellectual property or other rights owned by Stability AI embodied in the Stability AI Materials to use, reproduce, distribute, and create Derivative Works of, and make modifications to, the Stability AI Materials for any Commercial Purpose. “Commercial Purpose” means any purpose other than a Research Purpose or Non-Commercial Purpose that is primarily intended for commercial advantage or monetary compensation to You or others, including but not limited to, (i) creating, modifying, or distributing Your product or service, including via a hosted service or application programming interface, and (ii) for Your business’s or organization’s internal operations. 
+If You are using or distributing the Stability AI Materials for a Commercial Purpose, You must register with Stability AI at (https://stability.ai/community-license). If at any time You or Your Affiliate(s), either individually or in aggregate, generate more than USD $1,000,000 in annual revenue (or the equivalent thereof in Your local currency), regardless of whether that revenue is generated directly or indirectly from the Stability AI Materials or Derivative Works, any licenses granted to You under this Agreement shall terminate as of such date. You must request a license from Stability AI at (https://stability.ai/enterprise) , which Stability AI may grant to You in its sole discretion. If you receive Stability AI Materials, or any Derivative Works thereof, from a Licensee as part of an integrated end user product, then Section III of this Agreement will not apply to you.
+
+4. GENERAL TERMS
+
+Your Research, Non-Commercial, and Commercial License(s) under this Agreement are subject to the following terms.
+a.  Distribution & Attribution. If You distribute or make available the Stability AI Materials or a Derivative Work to a third party, or a product or service that uses any portion of them, You shall: (i) provide a copy of this Agreement to that third party, (ii) retain the following attribution notice within a "Notice" text file distributed as a part of such copies: "This Stability AI Model is licensed under the Stability AI Community License, Copyright ©  Stability AI Ltd. All Rights Reserved”, and (iii) prominently display “Powered by Stability AI” on a related website, user interface, blogpost, about page, or product documentation.  If You create a Derivative Work, You may add your own attribution notice(s) to the “Notice” text file included with that Derivative Work, provided that You clearly indicate which attributions apply to the Stability AI Materials and state in the “Notice” text file that You changed the Stability AI Materials and how it was modified.
+b.  Use Restrictions. Your use of the Stability AI Materials and Derivative Works, including any output or results of the Stability AI Materials or Derivative Works, must comply with applicable laws and regulations (including Trade Control Laws and equivalent regulations) and adhere to the Documentation and Stability AI’s AUP, which is hereby incorporated by reference. Furthermore, You will not use the Stability AI Materials or Derivative Works, or any output or results of the Stability AI Materials or Derivative Works, to create or improve any foundational generative AI model (excluding the Models or Derivative Works). 
+c.  Intellectual Property. 
+(i) Trademark License.  No trademark licenses are granted under this Agreement, and in connection with the Stability AI Materials or Derivative Works, You may not use any name or mark owned by or associated with Stability AI or any of its Affiliates, except as required under Section IV(a) herein.
+(ii)  Ownership of Derivative Works.  As between You and Stability AI, You are the owner of Derivative Works You create, subject to Stability AI’s ownership of the Stability AI Materials and any Derivative Works made by or for Stability AI.
+(iii)  Ownership of Outputs. As between You and Stability AI, You own any outputs generated from the Models or Derivative Works to the extent permitted by applicable law. 
+(iv)  Disputes.  If You or Your Affiliate(s) institute litigation or other proceedings against Stability AI (including a cross-claim or counterclaim in a lawsuit) alleging that the Stability AI Materials, Derivative Works or associated outputs or results, or any portion of any of the foregoing, constitutes infringement of intellectual property or other rights owned or licensable by You, then any licenses granted to You under this Agreement shall terminate as of the date such litigation or claim is filed or instituted. You will indemnify and hold harmless Stability AI from and against any claim by any third party arising out of or related to Your use or distribution of the Stability AI Materials or Derivative Works in violation of this Agreement.
+(v)  Feedback.  From time to time, You may provide Stability AI with verbal and/or written suggestions, comments or other feedback related to Stability AI’s existing or prospective technology, products or services (collectively, “Feedback”). You are not obligated to provide Stability AI with Feedback, but to the extent that You do, You hereby grant Stability AI a perpetual, irrevocable, royalty-free, fully-paid, sub-licensable, transferable, non-exclusive, worldwide right and license to exploit the Feedback in any manner without restriction. Your Feedback is provided “AS IS” and You make no warranties whatsoever about any Feedback.
+d.  Disclaimer Of Warranty. UNLESS REQUIRED BY APPLICABLE LAW, THE STABILITY AI MATERIALS AND ANY OUTPUT AND RESULTS THEREFROM ARE PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE. YOU ARE SOLELY RESPONSIBLE FOR DETERMINING THE APPROPRIATENESS OR LAWFULNESS OF USING OR REDISTRIBUTING THE STABILITY AI MATERIALS, DERIVATIVE WORKS OR ANY OUTPUT OR RESULTS AND ASSUME ANY RISKS ASSOCIATED WITH YOUR USE OF THE STABILITY AI MATERIALS, DERIVATIVE WORKS AND ANY OUTPUT AND RESULTS.
+e.  Limitation Of Liability. IN NO EVENT WILL STABILITY AI OR ITS AFFILIATES BE LIABLE UNDER ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, TORT, NEGLIGENCE, PRODUCTS LIABILITY, OR OTHERWISE, ARISING OUT OF THIS AGREEMENT, FOR ANY LOST PROFITS OR ANY DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL, EXEMPLARY OR PUNITIVE DAMAGES, EVEN IF STABILITY AI OR ITS AFFILIATES HAVE BEEN ADVISED OF THE POSSIBILITY OF ANY OF THE FOREGOING.
+f.  Term And Termination. The term of this Agreement will commence upon Your acceptance of this Agreement or access to the Stability AI Materials and will continue in full force and effect until terminated in accordance with the terms and conditions herein. Stability AI may terminate this Agreement if You are in breach of any term or condition of this Agreement. Upon termination of this Agreement, You shall delete and cease use of any Stability AI Materials or Derivative Works. Section IV(d), (e), and (g) shall survive the termination of this Agreement.
+g.  Governing Law.  This Agreement will be governed by and constructed in accordance with the laws of the United States and the State of California without regard to choice of law principles, and the UN Convention on Contracts for International Sale of Goods does not apply to this Agreement.
+
+5. DEFINITIONS 
+
+“Affiliate(s)” means any entity that directly or indirectly controls, is controlled by, or is under common control with the subject entity; for purposes of this definition, “control” means direct or indirect ownership or control of more than 50% of the voting interests of the subject entity.
+
+"Agreement" means this Stability AI Community License Agreement.
+
+“AUP” means the Stability AI Acceptable Use Policy available at (https://stability.ai/use-policy), as may be updated from time to time.
+
+"Derivative Work(s)” means (a) any derivative work of the Stability AI Materials as recognized by U.S. copyright laws and (b) any modifications to a Model, and any other model created which is based on or derived from the Model or the Model’s output, including “fine tune” and “low-rank adaptation” models derived from a Model or a Model’s output, but do not include the output of any Model.
+
+“Documentation” means any specifications, manuals, documentation, and other written information provided by Stability AI related to the Software or Models.
+
+“Model(s)" means, collectively, Stability AI’s proprietary models and algorithms, including machine-learning models, trained model weights and other elements of the foregoing listed on Stability’s Core Models Webpage available at (https://stability.ai/core-models), as may be updated from time to time.
+
+"Stability AI" or "we" means Stability AI Ltd. and its Affiliates.
+
+"Software" means Stability AI’s proprietary software made available under this Agreement now or in the future.
+
+“Stability AI Materials” means, collectively, Stability’s proprietary Models, Software and Documentation (and any portion or combination thereof) made available under this Agreement. 
+
+“Trade Control Laws” means any applicable U.S. and non-U.S. export control and trade sanctions laws and regulations.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@audiofool/moondog",
-  "version": "0.2.1",
+  "version": "0.3.0-beta.1",
   "type": "module",
   "description": "Local-first personal AI music agent.",
   "license": "Apache-2.0",
@@ -18,6 +18,8 @@
     "moondog": "scripts/moondog"
   },
   "files": [
+    "NOTICE",
+    "licenses/stability-ai-community-license.md",
     "assets/brand/moondog-logo.svg",
     "contracts/v1",
     "contracts/v2",

package/scripts/moondog.mjs

@@ -53,6 +53,7 @@ import { startListeningUpkeep } from "../src/core/listening-upkeep.mjs";
 import { createAppleMusicCatalog } from "../src/integrations/apple-music/catalog.mjs";
 import { createTerminalPreviewPlayer } from "../src/integrations/apple-music/terminal-preview-player.mjs";
 import { createNeteasePlayer } from "../src/integrations/netease/ncm-cli-player.mjs";
+import { createAtmosphereStream, createLocalGenerator } from "../src/integrations/stable-audio/local-generator.mjs";
 import { createMusicAppPlayer } from "../src/integrations/apple-music/music-app.mjs";
 import {
   createOpenMusicSimilarity,
@@ -850,11 +851,29 @@ async function main() {
   const neteasePlayer = createNeteasePlayer();
   const playbackService = await resolvePlaybackService();
   if (playbackService === "netease") await neteasePlayer.check();
+  // Moondog makes music on this Mac with the listener's own Stable Audio 3 once they turn it on, in a
+  // room that can play what it makes. The terminal and the window each keep one generator, so each
+  // makes one track at a time; a choice saved on one side is checked again on the other.
+  const localGenerator = previewPlayer ? createLocalGenerator() : null;
+  await localGenerator?.check();
+  void localGenerator?.sweep().catch(() => {});
+  const unwatchGeneration = localGenerator?.watch() ?? (() => {});
+  // How each made track landed (played through, skipped, stopped) comes from this room's player.
+  await localGenerator?.load();
+  const unobservePlayer = localGenerator ? previewPlayer.subscribe?.((event) => localGenerator.observe(event)) : null;
+  // Moondog's atmosphere stream: one per room, on its generator and its player, moved along by what the player reports.
+  const atmosphereStream = localGenerator && typeof previewPlayer?.enqueueGenerated === "function"
+    ? createAtmosphereStream({ generator: localGenerator, player: previewPlayer }) : null;
+  // After the generator's own observer: the stream may stop the player while an event is still being
+  // delivered, and the generator must record that event's outcome first.
+  const unobserveStream = atmosphereStream ? previewPlayer.subscribe?.((event) => atmosphereStream.observe(event)) : null;
+  // Music making turned off, here or on the other surface, ends the stream.
+  const unwatchStreamGeneration = atmosphereStream ? localGenerator.subscribe((status) => { if (status.state !== "ready") atmosphereStream.stop("generation_off"); }) : null;
   const playbackSelection = createPlaybackSelection({ service: playbackService, save: writePlaybackPreference });
   // The terminal and the window each run this core on one playback.json. A service chosen on the
   // other side reaches this side's picker and agents, and stops the previews this side plays.
   const unwatchPlayback = watchPlaybackPreference(playbackSelection, {
-    onChange: (service) => { if (service !== "apple_music") previewPlayer?.stop?.(); },
+    onChange: (service) => { if (service !== "apple_music") { atmosphereStream?.stop("service_change"); previewPlayer?.stop?.(); } },
   });
   // The main application and every conversation the window opens beside it are built from
   // this one list, so they cannot drift apart. Each passes in what may change after launch:
@@ -863,7 +882,7 @@ async function main() {
   const spotifyTopArtists = { read_at: null, artists: [] };
   const applicationOptions = ({ domainServices, domainServicesError, spotifyConnection, locale, playbackService }) => ({
     domainServices, domainServicesError, spotifyConnection, locale, playbackService, playbackSelection,
-    webResearch, memoryStore, musicCatalog, musicPreviewPlayer: previewPlayer, neteasePlayer, musicSimilarity, artistIdentityResolver,
+    webResearch, memoryStore, musicCatalog, musicPreviewPlayer: previewPlayer, neteasePlayer, localGenerator, atmosphereStream, musicSimilarity, artistIdentityResolver,
     spotifyTopArtists, musicApp,
   });
   const application = new MoondogApplication(applicationOptions({
@@ -1059,6 +1078,13 @@ async function main() {
         return prepareTuiHistoryImport(undefined, { recentPage, librarySnapshot, libraryUnavailable });
       },
       openImportHelp,
+      // Local generation: what the room shows and the switch the listener turns, in Settings or with /generation.
+      generation: localGenerator && {
+        status: () => localGenerator.status(),
+        check: () => localGenerator.check(),
+        save: (settings) => localGenerator.save(settings),
+        subscribe: (listener) => localGenerator.subscribe(listener),
+      },
       // The room asks whether a Last.fm key is set, and saves one the listener pastes.
       lastfm: {
         status: async () => {
@@ -1165,6 +1191,16 @@ async function main() {
     });
   } finally {
     unwatchPlayback();
+    unwatchGeneration();
+    // A made track still playing is stopped while the generator listens, so its outcome is kept.
+    if (localGenerator) {
+      previewPlayer?.stop?.();
+      await localGenerator.flush?.();
+    }
+    unobservePlayer?.();
+    unobserveStream?.();
+    unwatchStreamGeneration?.();
+    atmosphereStream?.stop("closed");
     listeningUpkeep?.stop();
     lyrics?.close();
     // Conversations close first: their domain services are forks of the main application's.

package/src/core/apple-projection-domain-services.mjs

@@ -4,6 +4,7 @@ import { createListenerProfileInput, savedListenerChoices } from "../profile/lis
 import { lyricSeedsFromProfile } from "./lyric-profile.mjs";
 import { cachedAvoidGate, createAvoidGate, listeningVersion } from "./listener-avoids.mjs";
 import { recordListenerChoice } from "../profile/listener-corrections.mjs";
+import { listenedNames } from "../profile/taste-compiler.mjs";
 import { normalizedTrackTitle } from "./track-title.mjs";
 import { collectionCoverage } from "../profile/music-providers.mjs";
 import { lstat } from "node:fs/promises";
@@ -1848,6 +1849,19 @@ export class AppleProjectionDomainServices {
     return (this.#listeningHistoryStore?.listenedTracks?.({ subjectId: this.#subjectId }) ?? []).some(heard => exactTitleArtistMatch(track, heard));
   }
 
+  // Every Avoid in force, imported bans included, as the play paths read them.
+  activeAvoids() {
+    const store = this.#listeningHistoryStore;
+    const avoids = store?.activeAvoidances?.({ subjectId: this.#subjectId }) ?? [];
+    return normalizeAppleCorrectionLabels({ listener_assertions: { avoids } }, this.#projection).listener_assertions.avoids
+      .map((avoid) => ({ stance: "avoid", subject: avoid.entity_type ?? "artist", name: avoid.label, ...(avoid.artist_credit ? { artist: avoid.artist_credit } : {}) }));
+  }
+
+  // Every artist, song and album the listener has played, so a track Moondog makes names none of them.
+  listenedNames() {
+    return listenedNames(this.#listeningHistoryStore?.listenedTracks?.({ subjectId: this.#subjectId }) ?? []);
+  }
+
   registerExternalCandidateSet({ tracks, source, excludeKnown = true } = {}) {
     if (
       !Array.isArray(tracks) ||

package/src/core/capability-catalog.mjs

@@ -601,6 +601,55 @@ const catalog = [
       label: N_("Save the playlist to Spotify"),
     },
   },
+  {
+    id: "music.generate.local",
+    version: "1",
+    state: "enabled",
+    effect: "generate_local",
+    description:
+      "Make an instrumental track on this Mac with the listener's own Stable Audio 3 install, shaped by their taste, and play it in Moondog's player. Stable Audio 3 runs offline; the track stays on this Mac.",
+    requires_local_generation: true,
+    agent_tool: {
+      name: "moondog_make_track",
+      label: N_("Make a track"),
+    },
+  },
+  {
+    id: "music.generate.replay",
+    version: "1",
+    state: "enabled",
+    effect: "generate_local",
+    description: "Play again a track Moondog made on this Mac, from its own folder.",
+    requires_local_generation: true,
+    agent_tool: {
+      name: "moondog_play_made_track",
+      label: N_("Play a track Moondog made"),
+    },
+  },
+  {
+    id: "music.generate.stream",
+    version: "1",
+    state: "enabled",
+    effect: "generate_local",
+    description: "Keep making instrumental tracks on this Mac from the listener's taste, one after another, until they stop it or the time runs out.",
+    requires_local_generation: true,
+    agent_tool: {
+      name: "moondog_start_stream",
+      label: N_("Start a stream"),
+    },
+  },
+  {
+    id: "music.generate.stream.stop",
+    version: "1",
+    state: "enabled",
+    effect: "generate_local",
+    description: "Stop Moondog's stream of tracks made on this Mac.",
+    requires_local_generation: true,
+    agent_tool: {
+      name: "moondog_stop_stream",
+      label: N_("Stop the stream"),
+    },
+  },
   {
     id: "music.generate",
     version: "1",
@@ -636,7 +685,11 @@ function withRuntimeAvailability(
   profileBuildReady,
   musicPreviewReady,
   tasteChoicesReady,
+  localGenerationReady,
 ) {
+  if (capability.requires_local_generation && !localGenerationReady) {
+    return { ...capability, state: "blocked", blocked_by: "local_generation_not_ready" };
+  }
   if (capability.requires_taste_choices && !tasteChoicesReady) {
     return { ...capability, state: "blocked", blocked_by: "taste_choices_not_ready" };
   }
@@ -769,6 +822,7 @@ export function listCapabilities({
   profileBuildReady = false,
   musicPreviewReady = false,
   tasteChoicesReady = false,
+  localGenerationReady = false,
 } = {}) {
   return structuredClone(
     catalog.map((capability) =>
@@ -791,6 +845,7 @@ export function listCapabilities({
         profileBuildReady,
         musicPreviewReady,
         tasteChoicesReady,
+        localGenerationReady,
       ),
     ),
   );

package/src/core/listening-profile-domain-services.mjs

@@ -4,6 +4,7 @@ import { createListenerProfileInput, savedListenerChoices } from "../profile/lis
 import { lyricSeedsFromProfile } from "./lyric-profile.mjs";
 import { cachedAvoidGate, listeningVersion } from "./listener-avoids.mjs";
 import { recordListenerChoice } from "../profile/listener-corrections.mjs";
+import { listenedNames } from "../profile/taste-compiler.mjs";
 
 import { isUuid } from "./uuid-v5.mjs";
 import { createListeningHistoryProfileProjection } from "../profile/spotify-archive-taste.mjs";
@@ -601,6 +602,17 @@ export class ListeningProfileDomainServices {
     return (this.#store.listenedTracks?.({ subjectId: this.#subjectId }) ?? []).some(heard => exactTitleArtistMatch(track, heard));
   }
 
+  // Every Avoid in force, imported bans included, as the play paths read them.
+  activeAvoids() {
+    return (this.#store.activeAvoidances?.({ subjectId: this.#subjectId }) ?? [])
+      .map((avoid) => ({ stance: "avoid", subject: avoid.entity_type ?? "artist", name: avoid.label, ...(avoid.artist_credit ? { artist: avoid.artist_credit } : {}) }));
+  }
+
+  // Every artist, song and album the listener has played, so a track Moondog makes names none of them.
+  listenedNames() {
+    return listenedNames(this.#store.listenedTracks?.({ subjectId: this.#subjectId }) ?? []);
+  }
+
   registerExternalCandidateSet({ tracks, source, excludeKnown = true } = {}) {
     if (!Array.isArray(tracks) || tracks.length < 1 || tracks.length > HISTORY_MAX_ITEMS) {
       throw new TypeError("External catalog candidates are invalid");

package/src/core/moondog-application.mjs

@@ -5,6 +5,8 @@ import { compactListenerProfile, readListenerProfile } from "../profile/listener
 import { mixCounts, songKeys } from "../profile/moondog-suggestions.mjs";
 import { ARTIST_CREDIT_SEPARATORS } from "./listener-avoids.mjs";
 import { textNamesSong } from "./track-title.mjs";
+import { compileTaste, tasteSources } from "../profile/taste-compiler.mjs";
+import { stableAudioPrompt } from "../integrations/stable-audio/local-generator.mjs";
 
 import {
   readAppleMusicSourceStatus,
@@ -221,6 +223,8 @@ export class MoondogApplication {
     musicSimilarity = null,
     musicPreviewPlayer = null,
     neteasePlayer = null,
+    localGenerator = null,
+    atmosphereStream = null,
     musicApp = null,
     agentHostNotes = [],
     artistIdentityResolver = null,
@@ -266,6 +270,10 @@ export class MoondogApplication {
     this.musicPreviewPlayer = musicPreviewPlayer;
     // NetEase Cloud Music through ncm-cli (src/integrations/netease), shared by every conversation.
     this.neteasePlayer = neteasePlayer;
+    // Stable Audio 3 on this Mac (src/integrations/stable-audio), shared by every conversation, so one track is made at a time.
+    this.localGenerator = localGenerator;
+    // Moondog's atmosphere stream on that generator, one per room (src/integrations/stable-audio).
+    this.atmosphereStream = atmosphereStream;
     // The Music app on this Mac (src/integrations/apple-music/music-app.mjs), read for what the
     // listener plays there themselves.
     this.musicApp = musicApp;
@@ -523,6 +531,174 @@ export class MoondogApplication {
     return this.neteasePlayer;
   }
 
+  // Moondog makes music on this Mac once the listener turned it on and the install is ready, in a
+  // host whose player can play a local track: the terminal room and the window, not one-shot commands.
+  localGenerationReady() {
+    return this.localGenerator?.ready?.() === true && typeof this.musicPreviewPlayer?.playGenerated === "function";
+  }
+
+  generationStatus() {
+    return this.localGenerator?.status?.() ?? null;
+  }
+
+  // Moondog's newest tracks and how each landed, for the agent to calibrate the next one by. They
+  // are outcomes of Moondog's own picks, never the listener's taste.
+  // Each reply reads the made tracks again, so the other surface's tracks and outcomes show too.
+  async refreshMadeTracks() {
+    if (this.localGenerationReady()) await this.localGenerator.load?.();
+  }
+
+  madeTracks() {
+    if (!this.localGenerationReady()) return null;
+    const tracks = this.localGenerator.recentTracks?.(5) ?? [];
+    return tracks.length ? tracks : null;
+  }
+
+  // Plays a track Moondog made again. A track the listener named in their own words is their pick:
+  // it stays out of the ledger and counts as their replay. Otherwise it is Moondog's pick again.
+  async playMadeTrack({ id } = {}, { request = null, signal } = {}) {
+    if (!this.localGenerationReady()) throw Object.assign(new Error("Local generation is not ready. The listener can turn it on in Settings or with /generation."), { code: "generation_not_ready" });
+    const receipt = await this.localGenerator.receipt(id);
+    if (!receipt) throw Object.assign(new Error("There is no track Moondog made with that id on this Mac."), { code: "made_track_not_found" });
+    const file = await this.localGenerator.trackFile(id);
+    if (!file) throw Object.assign(new Error("That track was part of a stream, which keeps only its newest tracks' audio; its receipt is still here."), { code: "made_track_audio_not_kept" });
+    // Playing one of Moondog's tracks again ends its stream, on every surface.
+    await this.#endStream("replaced");
+    const title = String(receipt.title ?? "");
+    // Named means quoted, or the title with Moondog, as on every play path: an open request shares
+    // words with the plain titles Moondog gives its records ("something for a rainy day").
+    const named = typeof request === "string" && textNamesSong(request, title, ["Moondog"]);
+    await this.quietOtherPlayers("apple_music", { signal });
+    // A reply stopped before the track starts plays nothing, and no replay is recorded.
+    if (signal?.aborted) throw Object.assign(new Error("Nothing was played, because the reply was stopped."), { code: "generation_stopped" });
+    // Nothing waits between this check and the play; the replay is written once it plays.
+    this.localGenerator.restart?.(id);
+    this.musicPreviewPlayer.playGenerated({ id, title, seconds: receipt.audio?.duration_seconds, file });
+    if (!named) this.#noteGeneratedPlay({ id, title });
+    await this.localGenerator.recordReplay?.(id, named ? "listener" : "moondog");
+    return { state: "playing", track: { id, title, seconds: receipt.audio?.duration_seconds ?? null }, chosen_by: named ? "listener" : "moondog" };
+  }
+
+  // Makes one instrumental track from the listener's taste and plays it in Moondog's own player.
+  // The agent proposes sound descriptors, each with its source; the taste compiler keeps only the
+  // ones it can trace and none that names an artist or a song. The track and its receipt stay on
+  // this Mac, and its play goes in the ledger as Moondog's own, never as the listener's attention.
+  // moment and request come from the agent's host, not from the model.
+  async makeTrack({ descriptors, bpm, bpmSource, seconds, title } = {}, { moment = null, request = null, transient = false, signal, onProgress } = {}) {
+    const { compiled, receipt } = await this.#compileForGeneration({ descriptors, bpm, bpmSource, title }, { moment, request, transient });
+    if (!compiled.usable) {
+      return { state: "not_made", reason: compiled.descriptors.length ? "needs_a_sound" : "no_traceable_descriptors", dropped: compiled.dropped };
+    }
+    const prompt = stableAudioPrompt(compiled);
+    await this.#endStream("replaced");
+    const made = await this.localGenerator.generate({ prompt, seconds, title: compiled.title, receipt }, { signal, onProgress });
+    // A reply stopped as the track finished keeps the track, but plays nothing over what is on now.
+    await this.quietOtherPlayers("apple_music", { signal });
+    // The terminal plays the file itself; the window asks for it by id and never sees the path.
+    const file = await this.localGenerator.trackFile(made.id);
+    // A reply stopped while the track was made, or while the other players paused, keeps the track but plays nothing.
+    if (signal?.aborted) throw Object.assign(new Error("The track was made but not played, because the reply was stopped."), { code: "generation_stopped" });
+    this.musicPreviewPlayer.playGenerated({ id: made.id, title: made.title, seconds: made.duration_seconds, file });
+    this.#noteGeneratedPlay(made);
+    return { state: "playing", track: { id: made.id, title: made.title, seconds: made.duration_seconds, seed: made.seed },
+      prompt, shaped_by: compiled.descriptors, sources: tasteSources(compiled.descriptors), left_out: compiled.dropped,
+      ...(compiled.bpm ? { bpm: compiled.bpm } : {}), elapsed_ms: made.elapsed_ms };
+  }
+
+  // The taste compiled for a track or a stream, and what its receipts keep of why.
+  async #compileForGeneration({ descriptors, bpm, bpmSource, title }, { moment, request, transient }) {
+    if (!this.localGenerationReady()) throw Object.assign(new Error("Local generation is not ready. The listener can turn it on in Settings or with /generation."), { code: "generation_not_ready" });
+    this.requireListenerAvoids();
+    const context = await this.#tasteContext({ descriptors, moment, request });
+    const compiled = compileTaste({ descriptors, bpm, bpm_source: bpmSource, title }, context);
+    return { compiled, receipt: {
+      shaped_by: compiled.descriptors, left_out: compiled.dropped,
+      ...(compiled.bpm ? { bpm: compiled.bpm, bpm_source: compiled.bpm_source } : {}),
+      // A conversation that read Spotify stays out of memory, and its words out of the receipt too.
+      ...(typeof request === "string" && !transient && !this.transientSpotifyContext ? { request: Array.from(request).slice(0, 300).join("") } : {}),
+      avoids_in_force: context.avoids.length,
+    } };
+  }
+
+  // A stream needs a player that can queue a made track behind the one playing.
+  streamReady() {
+    return this.localGenerationReady() && typeof this.atmosphereStream?.start === "function" &&
+      typeof this.musicPreviewPlayer?.enqueueGenerated === "function";
+  }
+
+  streamStatus() {
+    return this.atmosphereStream?.status?.() ?? null;
+  }
+
+  // Starts Moondog's atmosphere stream from the listener's taste: its first track plays now, and
+  // each next one is made while the last plays. Every track goes in the ledger as Moondog's pick.
+  async startStream({ descriptors, bpm, bpmSource, seconds, minutes, title } = {}, { moment = null, request = null, transient = false, signal, onProgress } = {}) {
+    if (!this.streamReady()) throw Object.assign(new Error("A stream can't run here. Music making must be on, in the terminal room or the window."), { code: "stream_not_ready" });
+    const { compiled, receipt } = await this.#compileForGeneration({ descriptors, bpm, bpmSource, title }, { moment, request, transient });
+    if (!compiled.usable) {
+      return { state: "not_made", reason: compiled.descriptors.length ? "needs_a_sound" : "no_traceable_descriptors", dropped: compiled.dropped };
+    }
+    await this.#endStream("replaced");
+    // Other music pauses only once the first track exists, as for a single track.
+    const { made, prompt } = await this.atmosphereStream.start({ compiled, title: compiled.title, seconds, minutes, receipt },
+      { signal, onProgress, onTrack: (track) => this.#noteGeneratedPlay(track), beforePlay: () => this.quietOtherPlayers("apple_music", { signal }) });
+    return { state: "streaming", minutes, track: { id: made.id, title: made.title, seconds: made.duration_seconds, seed: made.seed },
+      prompt, shaped_by: compiled.descriptors, sources: tasteSources(compiled.descriptors), left_out: compiled.dropped,
+      ...(compiled.bpm ? { bpm: compiled.bpm } : {}), elapsed_ms: made.elapsed_ms };
+  }
+
+  // A single track or a new stream takes over from a running stream, once its next track stops being made.
+  async #endStream(reason) {
+    if (!this.atmosphereStream?.active?.()) return;
+    this.atmosphereStream.stop(reason);
+    for (let waited = 0; this.localGenerator?.busy?.() && waited < 5_000; waited += 100) await delay(100);
+  }
+
+  stopStream() {
+    const stopped = this.atmosphereStream?.stop?.("asked") ?? null;
+    return stopped ? { state: "stopped", tracks_made: stopped.tracks_made } : { state: "not_running" };
+  }
+
+  // What the compiler may trace a descriptor to. Each cited finding is read from the saved reading.
+  async #tasteContext({ descriptors, moment, request }) {
+    const choices = this.domainServices?.listenerChoices?.()?.items ?? [];
+    // Every Avoid in force, not only the newest choices, so an old one still keeps its artist out.
+    let avoids = null;
+    try { avoids = this.domainServices?.activeAvoids?.() ?? null; } catch { /* The newest choices still hold. */ }
+    const recent = this.domainServices?.recentAttention?.() ?? null;
+    const cited = [...new Set((Array.isArray(descriptors) ? descriptors : [])
+      .filter((descriptor) => descriptor?.source === "reading" && typeof descriptor.from === "string").map((descriptor) => descriptor.from.trim()))].slice(0, 12);
+    const claims = new Map();
+    let revisionId = null;
+    for (const claimId of cited) {
+      try {
+        const reading = await this.getListenerProfile({ claimId });
+        if (reading?.claim) { claims.set(claimId, reading.claim); revisionId ??= reading.revision_id ?? null; }
+      } catch { /* Not a finding of the saved reading; the compiler drops it. */ }
+    }
+    let listened = null;
+    try { listened = this.domainServices?.listenedNames?.() ?? null; } catch { /* Without a history, only choices are checked. */ }
+    return {
+      claim: (id) => claims.get(id) ?? null, revisionId,
+      likes: choices.filter((choice) => choice.stance === "like"),
+      avoids: Array.isArray(avoids) ? avoids : choices.filter((choice) => choice.stance === "avoid"),
+      recentArtists: recent?.top_artists ?? [],
+      ...(recent?.from_date ? { recentWindow: { from_date: recent.from_date, through_date: recent.through_date } } : {}),
+      historyArtists: listened?.artists ?? [], historyTitles: listened?.titles ?? [],
+      avoidsName: (name) => !this.avoidAllows({ artist_credit: name, artists: [name] }),
+      moment, request,
+    };
+  }
+
+  // A track Moondog made and played is its own pick by definition, so no listener-named check applies.
+  #noteGeneratedPlay(made) {
+    if (typeof this.domainServices?.recordMoondogSuggestions !== "function") return;
+    try {
+      this.domainServices.recordMoondogSuggestions([{ service: "moondog", action: "generated.play", providerTrackId: `moondog:generated:${made.id}`,
+        title: made.title, artistCredit: "", requestedAt: new Date(this.spotifyContextClock()).toISOString() }]);
+    } catch { /* The track still plays; only its origin goes unrecorded. The receipt stays. */ }
+  }
+
   async searchNetease({ query, limit, intent } = {}) {
     const songs = await this.requireNetease().search({ query, limit, intent });
     return Array.isArray(songs) ? this.#withSuggestedBefore(songs, song => ({ service: "netease",
@@ -645,7 +821,10 @@ export class MoondogApplication {
         if (starting !== "netease" && this.neteaseReady() && (await this.neteasePlayer.nowPlaying()).state === "playing") await this.neteasePlayer.pause();
       })(),
       (async () => {
-        if (starting !== "apple_music") this.musicPreviewPlayer?.stop?.();
+        if (starting === "apple_music") return;
+        // Other music ends Moondog's stream too, even while its next track is still being made.
+        this.atmosphereStream?.stop?.("other_music");
+        this.musicPreviewPlayer?.stop?.();
       })(),
     ]);
   }
@@ -654,6 +833,7 @@ export class MoondogApplication {
   async #stopPlaybackService(service) {
     try {
       if (service === "apple_music") {
+        this.atmosphereStream?.stop?.("service_change");
         this.musicPreviewPlayer?.stop?.();
         // The listener's own Music app too, when it plays.
         if ((await this.musicApp?.nowPlaying?.())?.state === "playing") await this.musicApp.pause();
@@ -706,6 +886,9 @@ export class MoondogApplication {
     }
     if (avoided) found.skipped_avoided_count = avoided;
     if (found.played.length) {
+      // Songs Moondog plays end its stream, even one whose first track is still being made; the
+      // stream's own tracks also start through quietOtherPlayers("apple_music"), so it can't do this.
+      this.atmosphereStream?.stop?.("other_music");
       await this.quietOtherPlayers("apple_music");
       await this.musicPreviewPlayer.play(structuredClone(found.played), found.album ? { album: structuredClone(found.album) } : {});
     }
@@ -3298,15 +3481,18 @@ export class MoondogApplication {
         ...this.webLookupOptions(),
       musicPreviewReady: this.musicPreviewReady(),
       tasteChoicesReady: this.tasteChoicesReady(),
+      localGenerationReady: this.localGenerationReady(),
       }).map(capability => capability.state === "enabled" && this.#playbackServiceExcludes(capability.id)
         ? { ...capability, state: "blocked", blocked_by: capability.id === "listening.now" ? "no_readable_player" : capability.id === "music_app.control" ? "no_music_app" : capability.id === "playback.service" ? "no_playback_service"
-          : neteaseCapabilities.has(capability.id) ? "netease_not_ready" : "playback_service_not_spotify" } : capability),
+          : neteaseCapabilities.has(capability.id) ? "netease_not_ready" : capability.id.startsWith("music.generate.stream") ? "stream_not_ready"
+          : "playback_service_not_spotify" } : capability),
     };
   }
 
   // With another music service chosen, Spotify does not play or queue anything; NetEase's
   // tools exist only while it plays. What the listener plays is read wherever it can be.
   #playbackServiceExcludes(capabilityId) {
+    if (capabilityId.startsWith("music.generate.stream")) return !this.streamReady();
     if (capabilityId === "listening.now") return !this.listeningReadable();
     if (capabilityId === "music_app.control") return this.musicApp?.available !== true;
     if (capabilityId === "playback.service") return !this.playbackStatus().services.some((entry) => entry.available);
@@ -3333,6 +3519,7 @@ export class MoondogApplication {
       ...this.webLookupOptions(),
       musicPreviewReady: this.musicPreviewReady(),
       tasteChoicesReady: this.tasteChoicesReady(),
+      localGenerationReady: this.localGenerationReady(),
     }).filter(descriptor => !this.#playbackServiceExcludes(descriptor.capability_id));
   }
 
@@ -3806,6 +3993,12 @@ export class MoondogApplication {
         ok: true,
         state: this.spotifyReady() ? "spotify_control" : "disabled",
       },
+      {
+        id: "music.generate.local",
+        ok: this.localGenerationReady(),
+        state: this.generationStatus()?.state ?? "unavailable",
+        optional_for_local_commands: true,
+      },
       {
         id: "spotify.connection",
         ok: this.spotifyReady(),

package/src/i18n/messages/de.mjs

@@ -130,6 +130,8 @@ export default {
   "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}.`; },
+  "generate.made": ({ title, length, seed }) => `Auf diesem Mac mit Stable Audio 3 gemacht: „${title}“ (${length}, Seed ${seed}).`,
+  "generate.stream": ({ minutes }) => `Der Stream läuft auf diesem Mac weiter, jedes Mal mit einem neuen Stück, bis zu ${minutes} Minuten. Du kannst ihn jederzeit stoppen.`,
   "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

@@ -131,6 +131,8 @@ export default {
   "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}.`; },
+  "generate.made": ({ title, length, seed }) => `Made on this Mac with Stable Audio 3: "${title}" (${length}, seed ${seed}).`,
+  "generate.stream": ({ minutes }) => `The stream keeps going on this Mac, a new track each time, for up to ${minutes} minutes. Stop it any time.`,
   "turn.cancelled": "Cancelled further work.",
   "turn.interrupted": "The response was interrupted. The recorded Spotify outcomes are below; no action was replayed.",
 };