@audiofool/moondog 0.2.2 → 0.3.0-beta.1

package/src/runtime/pi/agent-runtime.mjs

@@ -4,6 +4,8 @@ import { readFileSync } from "node:fs";
 import { LOCALES, messageLocale, translator } from "../../i18n/index.mjs";
 import { PROFILE_SECTIONS, TRAJECTORIES } from "../../profile/profile-exploration.mjs";
 import { compactListenerProfile } from "../../profile/listener-profile-build.mjs";
+import { BPM_RANGE, DESCRIPTOR_FACETS, DESCRIPTOR_LIMITS, DESCRIPTOR_SOURCES } from "../../profile/taste-compiler.mjs";
+import { GENERATION_SECONDS } from "../../integrations/stable-audio/local-generator.mjs";
 import { avoidKey } from "../../core/listener-avoids.mjs";
 import { foldedWords, isCjkText, textNames, textNamesArtist } from "../../core/track-title.mjs";
 
@@ -177,7 +179,9 @@ function agentCapabilityAllowed(descriptor) {
       spotifyCapabilityEffects.has(descriptor.effect)) ||
     (descriptor.capability_id.startsWith("netease.") &&
       spotifyCapabilityEffects.has(descriptor.effect)) ||
-    (descriptor.capability_id === "music.preview.play" && descriptor.effect === "play_preview")
+    (descriptor.capability_id === "music.preview.play" && descriptor.effect === "play_preview") ||
+    (["music.generate.local", "music.generate.replay", "music.generate.stream", "music.generate.stream.stop"].includes(descriptor.capability_id) &&
+      descriptor.effect === "generate_local")
   );
 }
 
@@ -3181,6 +3185,52 @@ function renderMix(value, t) {
   return value?.mix ? t("queue.mix", value.mix) : null;
 }
 
+// What the model learns of a track Moondog made: what shaped it and what was left out, and never
+// where the file is.
+function projectGeneratedTrack(value) {
+  if (!isPlainObject(value) || !["playing", "not_made"].includes(value.state)) throw new Error("domain_result_invalid:generated_track");
+  const leftOut = (Array.isArray(value.left_out ?? value.dropped) ? value.left_out ?? value.dropped : []).slice(0, 24).map((entry) => ({
+    term: cleanOutputText(entry?.term || "-", 64, "generated_left_out_term"),
+    reason: cleanOutputText(entry?.reason, 32, "generated_left_out_reason"),
+  }));
+  if (value.state === "not_made") return { state: "not_made", reason: cleanOutputText(value.reason, 64, "generated_reason"), left_out: leftOut };
+  const source = (entry) => ({
+    kind: cleanOutputText(entry?.kind, 16, "generated_source_kind"),
+    ...(entry?.claim_id ? { claim_id: cleanOutputText(entry.claim_id, 64, "generated_claim") } : {}),
+    ...(entry?.label ? { from: cleanOutputText(entry.label, 256, "generated_from") } : {}),
+    ...(entry?.artist ? { artist: cleanOutputText(entry.artist, 256, "generated_artist") } : {}),
+    ...(entry?.part_of_day ? { part_of_day: cleanOutputText(entry.part_of_day, 32, "generated_part_of_day") } : {}),
+  });
+  return {
+    state: "playing",
+    made_with: "Stable Audio 3 Medium, on this Mac",
+    track: {
+      id: cleanOutputText(value.track?.id, 64, "generated_id"),
+      title: cleanOutputText(value.track?.title, 128, "generated_title"),
+      seconds: safeNonnegativeInteger(Math.round(value.track?.seconds ?? 0), "generated_seconds"),
+      seed: safeNonnegativeInteger(value.track?.seed ?? 0, "generated_seed"),
+    },
+    prompt: cleanOutputText(value.prompt, 1_024, "generated_prompt"),
+    shaped_by: (Array.isArray(value.shaped_by) ? value.shaped_by : []).slice(0, DESCRIPTOR_LIMITS.total).map((entry) => ({
+      term: cleanOutputText(entry?.term, 64, "generated_term"), facet: cleanOutputText(entry?.facet, 16, "generated_facet"), source: source(entry?.source),
+    })),
+    left_out: leftOut,
+    ...(Number.isInteger(value.bpm) ? { bpm: value.bpm } : {}),
+    seconds_to_make: Math.round((value.elapsed_ms ?? 0) / 100) / 10,
+  };
+}
+
+const trackLength = (seconds) => `${Math.floor(seconds / 60)}:${String(Math.round(seconds % 60)).padStart(2, "0")}`;
+
+function renderGeneratedTrack(value, t) {
+  if (value?.state === "streaming" && value.track) {
+    return [t("generate.made", { title: value.track.title, length: trackLength(value.track.seconds), seed: value.track.seed }),
+      t("generate.stream", { minutes: value.minutes })].join("\n");
+  }
+  return value?.state === "playing" && value.track
+    ? t("generate.made", { title: value.track.title, length: trackLength(value.track.seconds), seed: value.track.seed }) : null;
+}
+
 function projectSpotifyDiscovery(value) {
   if (!isPlainObject(value) || value.provider !== "spotify" || !["verified_candidates", "unavailable", "no_matches"].includes(value.state)) throw new Error("domain_result_invalid:spotify_discovery");
   const items = (value.items ?? []).slice(0, 36).map(item => {
@@ -4773,6 +4823,9 @@ function createToolFactories(
     onSpotifyPlaylistEditWrite,
     onExternalCandidateSet,
     onMusicPlayback,
+    onGeneratedTrack,
+    onMadeTrackPlayed,
+    generationContext,
     onMusicCatalogArtistReleases,
     onWebResearch,
     onSpotifyQueuePlan,
@@ -5134,6 +5187,146 @@ function createToolFactories(
         };
       },
     ],
+    [
+      "music.generate.local",
+      (descriptor) => {
+        const literals = (values) => Type.Union(values.map((value) => Type.Literal(value)));
+        const descriptorSchema = Type.Object(
+          {
+            term: Type.String({ minLength: 1, maxLength: DESCRIPTOR_LIMITS.characters }),
+            facet: literals(DESCRIPTOR_FACETS),
+            source: literals(DESCRIPTOR_SOURCES),
+            from: Type.Optional(Type.String({ minLength: 1, maxLength: 256 })),
+          },
+          { additionalProperties: false },
+        );
+        return {
+          name: descriptor.tool_name,
+          label: descriptor.label,
+          description:
+            "Make one instrumental track on this Mac with the listener's own Stable Audio 3, and play it at once in Moondog's player, whatever the music service. Use it only when the listener asks Moondog to make, compose or generate music; never to play existing songs. It needs no web research, search, candidate set or playlist plan: read the profile if it helps, then call this tool. Translate their taste into plain sound descriptors and give each its source: reading (from = a claim_id of the saved reading; none without one), choice (from = an artist or song they marked Like), recent (from = an artist in recent_attention.stored_plays, the last four weeks; not the profile's longer recent lists or Spotify's own top artists), moment (the listener_clock), or request (their words in this message). A term is one idea in a few plain words for a genre, instrument, texture, mood or rhythm, such as dream pop, rhodes piano, tape saturation, unhurried, brushed drums. Say what is in the sound, never what is absent (no drums): the model can't leave a named sound out, so naming it brings it in. moment is the listener's local day and hour as listener_clock gives them; a time the listener names, such as tonight, is request. Never put an artist or song name in a term or the title. The host leaves out any term that names one, cannot be traced, comes from something they Avoid, or asks for singing (the model makes instrumentals only); left_out says which and why. A track needs at least one genre, instrument, texture or mood. If state is not_made, fix the descriptors once from left_out and reason, or tell the listener what was missing. bpm is optional. seconds is 15 to 380, 120 when left out. title is Moondog's own name for the record, a few plain words. Making a track takes from a few seconds to about a minute; make at most one per message. Making one ends Moondog's stream if one runs. product.made_tracks lists Moondog's newest tracks with their sound and outcomes: lean away from the sound of tracks the listener skipped and toward what they played through or asked for again by name (asked_for_again). replayed_by_moondog counts Moondog's own replays and says nothing about the listener. A track with stream: true played in the background: its completions say little, but its skips still count. These are outcomes of Moondog's own picks, not the listener's taste; never call them likes. Once it plays, say in one or two sentences what shaped it in everyday words (their reading, a Like, what they play lately, the hour). Describe only what the result's prompt and shaped_by hold: the model takes no key, chord or melody, so never name one. Do not recite the descriptors, the prompt or the seed; the host writes its own line under the reply.",
+          parameters: Type.Object(
+            {
+              descriptors: Type.Array(descriptorSchema, { minItems: 1, maxItems: DESCRIPTOR_LIMITS.total }),
+              bpm: Type.Optional(Type.Integer({ minimum: BPM_RANGE.min, maximum: BPM_RANGE.max })),
+              bpm_source: Type.Optional(literals(["request", "moment", "reading"])),
+              seconds: Type.Optional(Type.Integer({ minimum: GENERATION_SECONDS.min, maximum: GENERATION_SECONDS.max })),
+              title: Type.Optional(Type.String({ minLength: 1, maxLength: 60 })),
+            },
+            { additionalProperties: false },
+          ),
+          executionMode: "sequential",
+          execute: executeDomain(
+            async (_toolCallId, parameters, signal, onUpdate) => application.makeTrack({
+              descriptors: parameters.descriptors, bpm: parameters.bpm, bpmSource: parameters.bpm_source,
+              seconds: parameters.seconds ?? GENERATION_SECONDS.default, title: parameters.title,
+            }, {
+              // The moment and the listener's words come from the host, never from the model.
+              ...(generationContext?.() ?? {}),
+              signal,
+              onProgress: ({ stage }) => onUpdate?.({ content: [{ type: "text", text: stage }], details: { stage } }),
+            }),
+            projectGeneratedTrack,
+            onGeneratedTrack,
+          ),
+        };
+      },
+    ],
+    [
+      "music.generate.stream",
+      (descriptor) => {
+        const literals = (values) => Type.Union(values.map((value) => Type.Literal(value)));
+        const descriptorSchema = Type.Object(
+          {
+            term: Type.String({ minLength: 1, maxLength: DESCRIPTOR_LIMITS.characters }),
+            facet: literals(DESCRIPTOR_FACETS),
+            source: literals(DESCRIPTOR_SOURCES),
+            from: Type.Optional(Type.String({ minLength: 1, maxLength: 256 })),
+          },
+          { additionalProperties: false },
+        );
+        return {
+          name: descriptor.tool_name,
+          label: descriptor.label,
+          description:
+            "Start Moondog's stream: instrumental tracks made on this Mac from the listener's taste, one after another, for background listening (work, reading, a long evening). The first plays at once; each next one is made while the last plays, and features a different few of the descriptors, so give a broad set: genres, plus several instruments, textures, moods and rhythms. Descriptors, sources and rules are the same as moondog_make_track. A track the listener skips within 30 seconds steers the stream away from what it featured. seconds is each track's length, 60 to 380, 150 when left out; minutes is how long the stream runs, 10 to 180, 60 when left out. Starting one replaces a stream already running, and making a single track ends it. Use it only when the listener asks for music to keep going in the background; for one track, use moondog_make_track. Say in one or two sentences what shapes it, and that they can stop it any time; the host writes its own line under the reply.",
+          parameters: Type.Object(
+            {
+              descriptors: Type.Array(descriptorSchema, { minItems: 1, maxItems: DESCRIPTOR_LIMITS.total }),
+              bpm: Type.Optional(Type.Integer({ minimum: BPM_RANGE.min, maximum: BPM_RANGE.max })),
+              bpm_source: Type.Optional(literals(["request", "moment", "reading"])),
+              seconds: Type.Optional(Type.Integer({ minimum: 60, maximum: GENERATION_SECONDS.max })),
+              minutes: Type.Optional(Type.Integer({ minimum: 10, maximum: 180 })),
+              title: Type.Optional(Type.String({ minLength: 1, maxLength: 60 })),
+            },
+            { additionalProperties: false },
+          ),
+          executionMode: "sequential",
+          execute: executeDomain(
+            async (_toolCallId, parameters, signal, onUpdate) => application.startStream({
+              descriptors: parameters.descriptors, bpm: parameters.bpm, bpmSource: parameters.bpm_source,
+              seconds: parameters.seconds ?? 150, minutes: parameters.minutes ?? 60, title: parameters.title,
+            }, {
+              ...(generationContext?.() ?? {}),
+              signal,
+              onProgress: ({ stage }) => onUpdate?.({ content: [{ type: "text", text: stage }], details: { stage } }),
+            }),
+            (value) => {
+              if (value?.state === "not_made") return projectGeneratedTrack(value);
+              if (value?.state !== "streaming") throw new Error("domain_result_invalid:stream");
+              return { ...projectGeneratedTrack({ ...value, state: "playing" }), state: "streaming", minutes: safeNonnegativeInteger(value.minutes ?? 0, "stream_minutes") };
+            },
+            onGeneratedTrack,
+          ),
+        };
+      },
+    ],
+    [
+      "music.generate.stream.stop",
+      (descriptor) => ({
+        name: descriptor.tool_name,
+        label: descriptor.label,
+        description: "Stop Moondog's stream of tracks made on this Mac when the listener asks to stop it. The track playing stops too.",
+        parameters: emptyParameters,
+        executionMode: "sequential",
+        execute: executeDomain(
+          async () => application.stopStream(),
+          (value) => ({ state: value?.state === "stopped" ? "stopped" : "not_running",
+            ...(Number.isInteger(value?.tracks_made) ? { tracks_made: value.tracks_made } : {}) }),
+        ),
+      }),
+    ],
+    [
+      "music.generate.replay",
+      (descriptor) => ({
+        name: descriptor.tool_name,
+        label: descriptor.label,
+        description:
+          "Play again a track Moondog made on this Mac, by its id from product.made_tracks, in Moondog's own player. Use it when the listener asks to hear one of Moondog's tracks again; to make a new one, use moondog_make_track. A track with audio_kept: false has only its receipt left, so it can't play again. Playing one again ends Moondog's stream if one runs. chosen_by says whether the listener named it (their own pick) or Moondog chose it.",
+        parameters: Type.Object(
+          { id: Type.String({ minLength: 36, maxLength: 36 }) },
+          { additionalProperties: false },
+        ),
+        executionMode: "sequential",
+        execute: executeDomain(
+          async (_toolCallId, parameters, signal) => application.playMadeTrack({ id: parameters.id },
+            { request: generationContext?.({ replay: true })?.request ?? null, signal }),
+          (value) => {
+            if (!isPlainObject(value) || value.state !== "playing") throw new Error("domain_result_invalid:made_track");
+            return {
+              state: "playing",
+              track: {
+                id: cleanOutputText(value.track?.id, 64, "made_track_id"),
+                title: cleanOutputText(value.track?.title, 128, "made_track_title"),
+                ...(Number.isFinite(value.track?.seconds) ? { seconds: Math.round(value.track.seconds) } : {}),
+              },
+              chosen_by: value.chosen_by === "listener" ? "listener" : "moondog",
+            };
+          },
+          onMadeTrackPlayed,
+        ),
+      }),
+    ],
     [
       "netease.search",
       (descriptor) => ({
@@ -6426,8 +6619,11 @@ function toolForModel(tool) {
 // Spotify can be connected for reading while the listener chose another service to play music.
 const SERVICE_NAMES = { apple_music: "Apple Music", netease: "NetEase Music (网易云音乐)" };
 
-function sessionAvailability({ spotifyReady, spotifyPlaybackReady = spotifyReady, previewReady, playbackService = "apple_music", neteaseReady = false }) {
-  if (spotifyPlaybackReady) return "";
+// Making a track plays in Moondog's own player under every music service.
+const GENERATION_LINE = "- moondog_make_track makes an instrumental track on this Mac from the listener's taste and plays it in Moondog's own player, whatever the music service. Use it only when they ask Moondog to make, compose or generate music, not to play songs that exist. moondog_play_made_track plays again one Moondog already made (product.made_tracks). When the stream tools are offered, moondog_start_stream keeps making tracks one after another for background listening, and moondog_stop_stream ends it.";
+
+function sessionAvailability({ spotifyReady, spotifyPlaybackReady = spotifyReady, previewReady, playbackService = "apple_music", neteaseReady = false, localGenerationReady = false }) {
+  if (spotifyPlaybackReady) return localGenerationReady ? `\n\nSession availability:\n${GENERATION_LINE}` : "";
   const lines = [
     "Session availability:",
     spotifyReady
@@ -6455,9 +6651,12 @@ function sessionAvailability({ spotifyReady, spotifyPlaybackReady = spotifyReady
         ? "- Do not suggest switching to Spotify or linking another account to play music here."
         : "- Do not suggest linking Spotify or another account to play music here.",
     );
+  } else if (localGenerationReady) {
+    lines.push("- No music service can play or queue songs in this session. Say so once, briefly, when the listener asks for songs; moondog_make_track can still make them a track of Moondog's own.");
   } else {
     lines.push("- You cannot play or queue music in this session. Say so once, briefly, then help with what you can: the song, its story, and what to try next.");
   }
+  if (localGenerationReady) lines.push(GENERATION_LINE);
   if (previewReady || neteaseReady) {
     lines.push(
       "- Playback verification belongs to the selected music service. Its play tool resolves and checks recordings. Use the returned songs and outcome to answer directly; do not run another catalog search or playlist planner just to recheck a successful playback result. A Spotify player or queue read cannot verify playback on another service.",
@@ -6478,6 +6677,7 @@ function sessionSection(application) {
     previewReady: application.musicPreviewReady?.() ?? false,
     playbackService: application.playbackService ?? "apple_music",
     neteaseReady: application.neteaseReady?.() ?? false,
+    localGenerationReady: application.localGenerationReady?.() ?? false,
   }).trim() || null;
 }
 
@@ -6490,6 +6690,7 @@ function playbackSurfaceKey(application) {
     application.musicPreviewReady?.() ?? false,
     application.neteaseReady?.() ?? false,
     application.listeningReadable?.() ?? false,
+    application.localGenerationReady?.() ?? false,
   ]);
 }
 
@@ -6638,7 +6839,7 @@ Output rules:
 - For a playlist with a stated size, return that many tracks. When the candidates cannot fill it with good fits, say so and ask before planning fewer. For a queue or an open pick, see Fewer, better.
 - For a library or history plan, explain the order and give a concrete reason for every selected track. The host shows an external plan as the songs plus one source line.
 - State uncertainty or ask to broaden the search when results are sparse.
-- Spotify playback controls, library saves, and private playlist writes may be used through the registered tools. Publishing, messaging, deletion, paid generation, and all other external effects remain disabled.
+- Spotify playback controls, library saves, and private playlist writes may be used through the registered tools. When the listener has turned it on, moondog_make_track makes music on this Mac, which nothing leaves. Publishing, messaging, deletion, paid or online generation, and all other external effects remain disabled.
 
 Curation craft:
 - Start from an anchor the listener already knows (a thread in the saved reading, an artist in recent attention, what is playing now) and move outward one step at a time: the same scene, era, producer, label, players or lineage. Name the anchor once.
@@ -7153,6 +7354,9 @@ function productContext(application, query, now, { runtime, source }) {
     spotify_playback_context: application.spotifyPlaybackContextStatus?.() ?? null,
     // A host that cannot know the listener's time zone passes no clock, and the time stays unknown.
     listener_clock: now ? listenerClock(now) : null,
+    // The tracks Moondog made lately and how each landed, once it can make them, and its stream while one runs.
+    ...(application.madeTracks?.() ? { made_tracks: application.madeTracks() } : {}),
+    ...(application.streamStatus?.() ? { stream: application.streamStatus() } : {}),
     reply_language: replyLanguage(query, application),
   };
 }
@@ -7328,6 +7532,39 @@ export class PiAgentRuntime {
           if (value.playing_in_order?.length) this.activePromptState.previewsPlaying = true;
         }
       },
+      // A track Moondog made, played again: a Like said while it plays is about Moondog's own record.
+      onMadeTrackPlayed: (value) => {
+        if (typeof value?.track?.title === "string") this.generatedTitles.add(avoidKey(value.track.title));
+      },
+      onGeneratedTrack: (value) => {
+        if (!["playing", "streaming"].includes(value?.state)) return;
+        this.generatedTitles.add(avoidKey(value.track.title));
+        this.activePromptState?.generatedTracks.push(structuredClone(value));
+      },
+      // A track is shaped by the moment and the listener's own words, which the host supplies and the
+      // model never does. One message makes at most one track, with one more try if nothing was made.
+      generationContext: ({ replay = false } = {}) => {
+        const state = this.activePromptState;
+        const refuse = (code, message) => { throw Object.assign(new Error(message), { code }); };
+        if (!state) refuse("generation_no_prompt", "A track can be made only while answering the listener.");
+        // Playing a made track again needs only the listener's words, to tell their pick from Moondog's.
+        if (replay) {
+          if (state.replays >= 1) refuse("generation_turn_limit", "Nothing more was played. One message plays at most one of Moondog's tracks again.");
+          state.replays += 1;
+          return { request: state.promptText };
+        }
+        if (state.generatedTracks.length > 0 || state.generationAttempts >= 2) {
+          refuse("generation_turn_limit", "Nothing more was made. One message makes at most one track; the listener can ask for another.");
+        }
+        state.generationAttempts += 1;
+        const now = this.clock?.();
+        return {
+          moment: now instanceof Date && Number.isFinite(now.getTime()) ? listenerClock(now) : null,
+          request: state.promptText,
+          // A conversation that read Spotify keeps the listener's words out of the receipt, as out of memory.
+          transient: this.transientSpotifyContext || this.application.transientSpotifyContext === true,
+        };
+      },
       onExternalCandidateSet: (value, { playbackLookup = false } = {}) => {
         if (this.activePromptState) {
           this.activePromptState.externalCandidateSetCreated = true;
@@ -7408,6 +7645,17 @@ export class PiAgentRuntime {
         }
         const track = parameters.subject === "track";
         if (track && !parameters.title) refuse("taste_choice_title_required", "Nothing was saved. A song choice needs its title and artist.");
+        // Moondog's own tracks have no artist, and "Moondog" is also a real composer's name. A choice is
+        // about a track Moondog made when it names one of their titles with Moondog as artist, puts such a
+        // title in place of the artist, or points at "this" while it names no song. Anything else, the
+        // real composer included, is saved as usual.
+        // Titles made in this session, and the newest ones on this Mac, which a replay may be playing.
+        const madeTitles = new Set([...this.generatedTitles, ...(application.madeTracks?.() ?? []).map((made) => avoidKey(made.title))]);
+        const madeHere = (value) => madeTitles.has(avoidKey(value ?? ""));
+        const moondog = avoidKey(parameters.artist ?? "") === "moondog";
+        if (madeHere(parameters.artist) || (moondog && (track ? madeHere(parameters.title) : quoteIsDeictic(quote) && madeTitles.size > 0))) {
+          refuse("taste_choice_generated_track", "Nothing was saved. This is a track Moondog made, and choices about Moondog's own tracks are not saved yet. Say so, and offer to make another one like it.");
+        }
         if (!quoteLongEnough(quote)) {
           refuse("taste_choice_quote_too_short", "Nothing was saved. source_text must quote the listener's whole statement of the choice, not one word.");
         }
@@ -7445,6 +7693,8 @@ export class PiAgentRuntime {
     };
     // Every tool name this agent has offered. One that later goes away left with a change of music service.
     this.offeredTools = new Set();
+    // The titles of the tracks this agent made, so a Like said while one plays is not saved as a real song's.
+    this.generatedTitles = new Set();
     const surface = this.#buildSurface();
     this.surfaceKey = surface.key;
     this.capabilityByToolName = surface.capabilities;
@@ -7666,6 +7916,9 @@ export class PiAgentRuntime {
       presentationFailure: false,
       stagedMemoryMutations: [],
       tasteChoices: [],
+      generatedTracks: [],
+      generationAttempts: 0,
+      replays: 0,
     };
     this.activePromptState = promptState;
     const profileDiscoveryUnavailable = () => Boolean(callbacks.profileSeed) &&
@@ -7742,6 +7995,8 @@ export class PiAgentRuntime {
       receipts.push(...unresolvedPlaybackFailures().map((failure) => renderSpotifyPlaybackFailure(failure, t)));
       return receipts;
     };
+    // A track that was made stays made, so its line stays when the turn is cancelled or interrupted too.
+    const generatedTexts = () => promptState.generatedTracks.map((track) => renderGeneratedTrack(track, t)).filter(Boolean);
     // A choice is saved at once, so its line stays even when the turn is cancelled or interrupted.
     const choiceTexts = () => promptState.tasteChoices.map((choice) => t(`choice.${choice.state === "retracted" ? "retract" : choice.stance}`, {
       title: choice.entity_type === "track" ? choice.label : "",
@@ -7787,7 +8042,7 @@ export class PiAgentRuntime {
       const queueMix = promptState.spotifyQueuePlan?.queued?.length ? renderMix(promptState.spotifyQueuePlan, t) : null;
       const playbackMix = renderMix(promptState.musicPlaybackResult, t);
       const leftOut = [promptState.spotifyQueuePlan, ...promptState.spotifyWriteReceipts].map((receipt) => renderSkippedAvoided(receipt, t));
-      for (const mix of [queueMix, playbackMix, ...leftOut]) {
+      for (const mix of [queueMix, playbackMix, ...leftOut, ...generatedTexts()]) {
         if (!mix || resultText.includes(mix)) continue;
         const addition = resultText ? `\n\n${mix}` : mix;
         resultText += addition;
@@ -7889,6 +8144,8 @@ export class PiAgentRuntime {
       if (ownEntryId && this.nameConversations) {
         try { ownSessionId = this.application.ensureMemorySession?.()?.session_id ?? null; } catch { /* The conversation keeps its first message as its name. */ }
       }
+      // The tracks Moondog made, read again, so the other surface's tracks and outcomes are in this reply's context.
+      try { await this.application.refreshMadeTracks?.(); } catch { /* The last read stands. */ }
       this.application.beginPrompt({ text, recentTexts: recentListenerTexts(this.agent.state.messages.slice(0, historyStartIndex)) });
       promptScopeStarted = true;
       if (callbacks.profileSeed) this.application.setProfileDiscoverySeed(callbacks.profileSeed);
@@ -7949,6 +8206,18 @@ export class PiAgentRuntime {
             });
           }
 
+          // A long tool, such as making a track, says which stage it is in.
+          if (event.type === "tool_execution_update" && typeof event.partialResult?.details?.stage === "string") {
+            const descriptor = this.capabilityByToolName.get(event.toolName);
+            callbacks.onToolUpdate?.({
+              toolCallId: event.toolCallId,
+              toolName: event.toolName,
+              capabilityId: descriptor?.capability_id ?? "unknown",
+              label: descriptor?.label ?? event.toolName,
+              stage: event.partialResult.details.stage,
+            });
+          }
+
           if (event.type === "tool_execution_end") {
             const descriptor = this.capabilityByToolName.get(event.toolName);
             const resultText = event.result?.content?.map((part) => part.text ?? "").join("") ?? "";
@@ -8022,7 +8291,7 @@ export class PiAgentRuntime {
         this.application.cancelSpotifyQueueRequest?.();
         discardPromptHistory(this.agent, historyStartIndex);
         historyFinalized = true;
-        const receipts = [...spotifyEffectTexts(), ...choiceTexts()];
+        const receipts = [...spotifyEffectTexts(), ...generatedTexts(), ...choiceTexts()];
         const abortedText = receipts.length > 0
           ? [t("turn.cancelled"), ...receipts].join("\n\n")
           : promptState.toolExecutionStarted ? "" : streamedText || finalText;
@@ -8137,8 +8406,8 @@ To confirm, reply: ${preview.confirmation}`].join("\n\n");
         // Discovered songs need a validated plan; a catalog lookup, such as whether a song is there, is reported in the model's words.
         promptState.externalCandidateSets.some((set) => !set.playbackLookup) &&
         !promptState.playlistPlanAttempted &&
-        // A song the model played, queued or failed to play is reported in its own words.
-        !promptState.musicPlaybackResult &&
+        // A song the model played, queued or failed to play is reported in its own words, as is a track it made.
+        !promptState.musicPlaybackResult && !promptState.generatedTracks.length &&
         !promptState.spotifyPlayback.length && !promptState.spotifyWriteReceipts.length && !promptState.spotifyPlaybackFailures.length
       ) {
         const safeFailureText = [renderUnvalidatedPlaylistPlan(t), ...spotifyEffectTexts()].join("\n\n");
@@ -8183,7 +8452,7 @@ To confirm, reply: ${preview.confirmation}`].join("\n\n");
       // its receipt. Keep only host evidence; discard model claims and staged
       // memory/plans. The caller can still display the returned receipt if its
       // streaming callback itself was the source of the exception.
-      const receipts = [...spotifyEffectTexts(), ...choiceTexts()];
+      const receipts = [...spotifyEffectTexts(), ...generatedTexts(), ...choiceTexts()];
       if (!receipts.length) throw error;
       const interruptedText = [t("turn.interrupted"), ...receipts].join("\n\n");
       compactCompletedPromptHistory(this.agent, historyStartIndex, interruptedText);

package/src/surfaces/cli/command-completions.mjs

@@ -93,6 +93,7 @@ export function withCommandCompletions(commands, {
     art: { argumentHint: "[braille|ascii|off|auto]", choices: firstArgument(artChoices) },
     motion: { argumentHint: "[on|off]", choices: firstArgument(motionChoices) },
     service: { argumentHint: "[spotify|apple_music|netease]", choices: firstArgument(serviceChoices) },
+    generation: { argumentHint: "[on [folder]|off]", choices: firstArgument(choices([["on", N_("Make music on this Mac with Stable Audio 3")], ["off", N_("Stop making music here")]])) },
     lyrics: { argumentHint: "[sync]", choices: firstArgument(choices([["sync", N_("Check profile songs for lyrics")]])) },
     web: { argumentHint: "search <query> | read <url> | status", choices: firstArgument(webChoices) },
     spotify: {

package/src/surfaces/cli/format-output.mjs

@@ -472,6 +472,7 @@ function formatTools(value, tr) {
 const doctorLabels = {
   "web.search": N_("Web search"),
   "web.read": N_("Web page reading"),
+  "music.generate.local": N_("Making music on this Mac"),
   "node.version": "Node.js",
   "apple_music.source": N_("Apple Music library"),
   "profile.projection": N_("Listening profile"),

package/src/surfaces/cli/tui.mjs

@@ -1,3 +1,4 @@
+import { homedir } from "node:os";
 import { LOCALES, N_, liveScreenTranslator, normalizeLocale } from "../../i18n/index.mjs";
 import {
   CombinedAutocompleteProvider,
@@ -53,6 +54,10 @@ import {
   setBrandText,
 } from "./brand-components.mjs";
 
+// What making a track says in the footer, stage by stage (src/integrations/stable-audio).
+const generationStages = { starting: N_("warming up"), reading: N_("reading your taste"), composing: N_("composing"),
+  decoding: N_("pressing the record"), writing: N_("saving it") };
+
 // The lines Moondog shows, as a radio host, while the model thinks; the window has the same ones.
 export const hostLines = (tr) => [tr("Reading the room"), tr("Checking the request line"), tr("Finding the groove"), tr("Working the decks"),
   tr("Planning the segue"), tr("Mic check"), tr("Riding the faders"), tr("Finding the cue")];
@@ -120,6 +125,7 @@ const slashCommands = [
   { name: "endpoint", description: N_("Add a model service by its address") },
   { name: "web", description: N_("Look things up on public music sites") },
   { name: "service", description: N_("Choose where Moondog plays music") },
+  { name: "generation", description: N_("Let Moondog make music on this Mac") },
   { name: "spotify", description: N_("Connect and control Spotify") },
   { name: "skip", description: N_("Skip to the next song preview") },
   { name: "stop", description: N_("Stop the song previews") },
@@ -223,6 +229,8 @@ export async function runMoondogTui({
   // The terminal's preview player. The room shows what it plays (subscribe) and
   // gives the listener /skip and /stop.
   previewPlayer,
+  // Making music on this Mac with Stable Audio 3: { status, check, save }, or nothing where the room can't play it.
+  generation,
   environment = process.env,
 }) {
   if (providers === listPiProviders && models === listPiModels) {
@@ -238,7 +246,8 @@ export async function runMoondogTui({
   // /skip and /stop exist only where the room controls the previews itself.
   const previewControls = typeof previewPlayer?.subscribe === "function" &&
     typeof previewPlayer.skip === "function" && typeof previewPlayer.stop === "function";
-  const commands = slashCommands.filter(({ name }) => previewControls || !["skip", "stop"].includes(name));
+  const commands = slashCommands.filter(({ name }) => (previewControls || !["skip", "stop"].includes(name)) &&
+    (name !== "generation" || typeof generation?.save === "function"));
   const localizedCommands = commands.map(({ name, description }) => ({ name, get description() { return tr.marked(description); } }));
   let activeRuntime = runtime;
   application.startNewSession?.("tui_start");
@@ -282,6 +291,8 @@ export async function runMoondogTui({
   let firstRunNote = null;
   let firstRunSetup = null;
   let firstRunTicket = 0;
+  // The skip being saved, which the room waits for before it closes.
+  let firstRunSaving = null;
   let stopWatchingFirstRun = null;
   let importPage = "start";
   let importReturnHome = false;
@@ -476,8 +487,10 @@ export async function runMoondogTui({
         // Where the terminal can't open links, the note in the conversation shows the address.
         const apple = getCapabilities().hyperlinks ? hyperlink("Apple Music", track.catalog_url) : "Apple Music";
         const state = type === "loading" ? tr("loading") : type === "paused" ? tr("paused") : "";
-        const controls = `  ${position}/${count}${state ? ` · ${state}` : ""} · ${apple} · /skip · /stop`;
-        const song = sanitizeTerminalText(`${track.title} · ${track.artist_credit}`).replace(/\s+/gu, " ").trim();
+        // A track Moondog made is its own record, kept on this Mac, with nothing to open elsewhere.
+        const controls = track.generated ? `${state ? `  ${state}` : ""}  · /stop`
+          : `  ${position}/${count}${state ? ` · ${state}` : ""} · ${apple} · /skip · /stop`;
+        const song = sanitizeTerminalText(`${track.title} · ${track.generated ? tr("Made by Moondog") : track.artist_credit}`).replace(/\s+/gu, " ").trim();
         const room = width - visibleWidth(prefix) - visibleWidth(controls);
         lines.push(paintBrandLine(room >= 12
           ? theme.accent(prefix) + theme.text(truncateToWidth(song, room, "…")) + theme.faint(controls)
@@ -702,7 +715,8 @@ export async function runMoondogTui({
   };
   const stopWatchingPreviews = previewControls ? previewPlayer.subscribe((event) => {
     if (cleanedUp) return;
-    if (event?.type === "queue") addPreviewNote(event);
+    // A track Moondog made needs no preview note: the reply names it, and the host's line says where it was made.
+    if (event?.type === "queue") { if (!event.tracks?.some((track) => track.generated)) addPreviewNote(event); }
     else if (event?.type === "failed") markPreviewFailed(event);
     else if (["loading", "playing", "paused"].includes(event?.type)) nowPlaying = event;
     else if (event?.type === "stopped") nowPlaying = null;
@@ -710,11 +724,45 @@ export async function runMoondogTui({
   }) : null;
   // These act at once, even while Moondog is answering.
   const controlPreviews = (command) => {
-    const acted = command === "stop" ? previewPlayer.stop() : previewPlayer.skip();
+    // /stop also ends Moondog's stream while its next track is still being made and nothing plays.
+    const streamStopped = command === "stop" && application.stopStream?.()?.state === "stopped";
+    const acted = command === "stop" ? previewPlayer.stop() || streamStopped : previewPlayer.skip();
     if (!busy) setFooter(!acted ? tr("No previews are playing.") : command === "stop" ? tr("Previews stopped.") : tr("Skipped."));
     tui.requestRender();
   };
 
+  // Making music on this Mac. /generation says where it stands; /generation on [folder] turns it on,
+  // with the folder of Stability AI's MLX build when it is not the usual one; /generation off turns it off.
+  const home = homedir();
+  const shownFolder = (folder) => sanitizeTerminalText(String(folder ?? "")).replace(home, "~");
+  const generationMessage = (status) => {
+    const folder = shownFolder(status?.path);
+    if (status?.install === "unsupported") return tr("Stable Audio 3 needs a Mac with Apple silicon, so Moondog can't make music here.");
+    if (status?.state === "ready") return tr("Moondog makes music on this Mac with Stable Audio 3, powered by Stability AI. Ask for a track. Stable Audio 3 runs offline, and the track stays on this Mac.");
+    if (status?.state === "off") {
+      if (status.install === "ready") return tr("Making music on this Mac is off. Stable Audio 3 is ready at {folder}; turn it on with /generation on.", { folder });
+      if (status.install === "incomplete") return tr("Making music on this Mac is off, and Stable Audio 3 at {folder} isn't fully installed. Run ./install.sh --download medium there, then use /generation on.", { folder });
+      return tr("Making music on this Mac is off, and Stable Audio 3 isn't at {folder}. Install Stability AI's MLX build from github.com/Stability-AI/stable-audio-3, then use /generation on with its folder.", { folder });
+    }
+    if (status?.state === "incomplete") {
+      return status.missing === "weights"
+        ? tr("Stable Audio 3 at {folder} doesn't have the Medium model yet. Run ./install.sh --download medium there, then use /generation again.", { folder })
+        : tr("Stable Audio 3 at {folder} isn't installed yet. Run ./install.sh --download medium there, then use /generation again.", { folder });
+    }
+    return tr("Stable Audio 3 isn't at {folder}. Use /generation on with the folder that holds its sa3 script.", { folder });
+  };
+  const manageGeneration = async (args) => {
+    const [action, ...rest] = args;
+    if ((action && !["on", "off"].includes(action)) || (action === "off" && rest.length)) {
+      throw new Error(tr("Use /generation, /generation on [folder], or /generation off."));
+    }
+    const status = action ? await generation.save({ enabled: action === "on", ...(rest.length ? { path: rest.join(" ") } : {}) })
+      : await generation.check();
+    addMoondogMessage(generationMessage(status));
+    setFooter(status.state === "ready" ? tr("Music making on.") : status.state === "off" ? tr("Music making off.") : tr("Music making isn't ready."),
+      status.state === "ready" || status.state === "off" ? dim : warning);
+  };
+
   const removeLifecycleListeners = () => {
     signalTarget.removeListener("SIGTERM", handleSigterm);
     signalTarget.removeListener("SIGHUP", handleSighup);
@@ -760,6 +808,8 @@ export async function runMoondogTui({
   };
 
   const shutdown = () => {
+    // A reply still running stops with the room, and so does a track it is making.
+    try { activeRuntime.abort(); } catch { /* Nothing was running. */ }
     cleanup();
     // The spoken line that closes Eclipse, the last thing on The Dark Side of the Moon.
     try {
@@ -1804,10 +1854,11 @@ export async function runMoondogTui({
       ? tr("All set. /spotify help shows how to connect Spotify.")
       : tr("All set. Say anything, or press Tab to look around."), success);
   };
-  // The view closes at once; the saved skip then reaches the window too.
+  // The view closes at once; the saved skip then reaches the window too, and a room closed right
+  // after Esc still saves it.
   const skipFirstRun = () => {
     closeFirstRun(tr("Skipped. /service and /model are here when you want them."));
-    void firstRun.finish({ skipped: true }).catch(() => {});
+    firstRunSaving = firstRun.finish({ skipped: true }).catch(() => {});
   };
   const handleFirstRunAction = async ({ type, value } = {}) => {
     if (busy || cleanedUp || !firstRunView) return;
@@ -2144,6 +2195,10 @@ export async function runMoondogTui({
       await pickService(args);
       return;
     }
+    if (command === "generation") {
+      await manageGeneration(args);
+      return;
+    }
     if (command === "spotify") {
       await runSpotifyCommand(args);
       return;
@@ -2312,7 +2367,7 @@ export async function runMoondogTui({
         setFooter(`/${command}...`);
         const argumentText = value.slice(1).trim().slice(rawCommand.length).trim();
         const parsedArgs = command === "import" ? argumentText ? [argumentText] : []
-          : ["profile", "spotify", "web"].includes(command)
+          : ["profile", "spotify", "web", "generation"].includes(command)
           ? parseTuiArguments(argumentText)
           : args;
         await runLocalCommand(command, parsedArgs);
@@ -2408,6 +2463,12 @@ export async function runMoondogTui({
           if (!cancellationRequested) setFooter(tr("Can't reach the model. Trying again ({attempt}/{max})...", { attempt, max: maxRetries }), warning);
         },
         onToolStart: (tool) => updateTool(tool, "running"),
+        // Making a track says where it is, from warming up to saving it.
+        onToolUpdate: (tool) => {
+          const stage = generationStages[tool?.stage];
+          if (cleanedUp || cancellationRequested || !stage) return;
+          setFooter(`${sanitizeTerminalText(tr.marked(tool.label ?? "Music tool"))} · ${tr.marked(stage)}...`);
+        },
         onToolEnd: (tool) => updateTool(tool, tool?.isError ? "failed" : "completed"),
         // The model names a new conversation after its first reply; the header shows that name from then on.
         onConversationNamed: ({ session_id, title }) => {
@@ -2739,6 +2800,7 @@ export async function runMoondogTui({
   } finally {
     cleanup();
     await lyricTask;
+    await firstRunSaving;
   }
   return exitRequest;
 }