@audiofool/moondog 0.2.1 → 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/runtime/pi/persistent-credential-store.mjs

@@ -668,38 +668,16 @@ export class PersistentCredentialStore {
     const release = await this.acquireLock(options);
     try {
       const document = await this.readDocument(options);
-      let current = document.credentials[providerId];
-      const persist = async (value) => {
-        const validated = validateCredential(providerId, value);
-        document.credentials[providerId] = validated;
-        await this.writeDocument(document, options);
-        current = validated;
-      };
-      let active = true;
-      let pending = Promise.resolve();
-      // A checkpoint is durable even if the callback later throws. Its
-      // lifetime is fenced to this transaction; all started writes drain
-      // before the lock is released, including accidentally unawaited ones.
-      const checkpoint = (value) => {
-        if (!active) throw safeError("credential_store_transaction_closed", "The credential transaction has ended.");
-        const validated = validateCredential(providerId, value);
-        pending = pending.then(() => persist(validated));
-        pending.catch(() => {});
-        return pending;
-      };
-      let next;
-      try {
-        next = await fn(current ? structuredClone(current) : undefined, { checkpoint });
-      } finally {
-        active = false;
-        await pending;
-      }
+      const current = document.credentials[providerId];
+      const next = await fn(current ? structuredClone(current) : undefined);
       assertNotAborted(options.signal);
       if (next === undefined) {
         return current ? structuredClone(current) : undefined;
       }
-      await persist(next);
-      return structuredClone(current);
+      const validated = validateCredential(providerId, next);
+      document.credentials[providerId] = validated;
+      await this.writeDocument(document, options);
+      return structuredClone(validated);
     } finally {
       await release();
     }

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"),