@pellux/goodvibes-agent 1.5.8 → 1.5.9

package/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 Product-facing release notes for GoodVibes Agent.
 
+## 1.5.9 - 2026-07-06
+
+- Fixed spoken output (text-to-speech) so playback no longer clips at the start: the Agent now waits until the audio player has actually started before sending it audio, instead of writing into a player that hasn't opened yet.
+- Fixed responses getting cut off at the end: playback now waits for the audio to fully drain before counting a response as finished, and quitting while the last bit of audio is still playing waits briefly for it to finish instead of killing it mid-sentence. A deliberate interrupt (stopping playback on purpose) still stops instantly.
+- Synthesis requests to the voice provider are now batched into as few requests as possible and capped at two running at the same time, so the Agent stays within the provider's concurrent-request limits (for example, an ElevenLabs plan's allowance) instead of firing one request per sentence.
+- Transient rate-limit errors from the voice provider now retry quietly in the background instead of stopping playback. If a piece of speech still fails after retrying, that piece is skipped with a single notice and the rest of the response keeps playing normally.
+
 ## 1.5.8 - 2026-07-06
 
 - The `memory` CLI command (`goodvibes-agent memory ...`) now writes to the same shared cross-surface memory store that the runtime, the terminal UI, and the SDK already read and write. Previously the CLI opened its own private database, so a memory added from the CLI was invisible everywhere else; a memory added from the CLI is now visible in the Agent runtime, the TUI, and the SDK, and vice versa.

package/README.md

@@ -1,7 +1,7 @@
 # GoodVibes Agent
 
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
-[![Version: 1.5.3](https://img.shields.io/badge/version-1.5.8-blue.svg)](#install)
+[![Version: 1.5.3](https://img.shields.io/badge/version-1.5.9-blue.svg)](#install)
 
 GoodVibes Agent is the installable autonomous operator assistant for GoodVibes. It keeps the existing terminal renderer and workspace bones, but the product goal is different from a vibecoding harness: the user should experience one assistant that can chat, plan, remember, research, schedule, send, generate, run visible agents, and operate the GoodVibes daemon contract with clear confirmation gates.
 

package/dist/package/main.js

@@ -830727,7 +830727,7 @@ var createStyledCell = (char, overrides = {}) => ({
 // src/version.ts
 import { readFileSync } from "fs";
 import { join } from "path";
-var _version = "1.5.8";
+var _version = "1.5.9";
 try {
   const pkg = JSON.parse(readFileSync(join(import.meta.dir, "..", "package.json"), "utf-8"));
   _version = typeof pkg.version === "string" ? pkg.version : _version;
@@ -967093,7 +967093,7 @@ class LocalStreamingAudioPlayer {
   activeProcess = null;
   spawnProcess;
   constructor(options = {}) {
-    this.command = resolveStreamingAudioPlayerCommand(options.env ?? process.env);
+    this.command = options.command !== undefined ? options.command : resolveStreamingAudioPlayerCommand(options.env ?? process.env);
     this.spawnProcess = options.spawnProcess ?? defaultSpawnProcess;
   }
   get label() {
@@ -967120,6 +967120,9 @@ class LocalStreamingAudioPlayer {
     };
     options.signal?.addEventListener("abort", abort6, { once: true });
     try {
+      await awaitReady(proc, options.signal);
+      if (options.signal?.aborted)
+        return;
       for await (const chunk of chunks) {
         if (options.signal?.aborted)
           break;
@@ -967127,7 +967130,11 @@ class LocalStreamingAudioPlayer {
           continue;
         await writeStdin(proc, chunk.data);
       }
-      proc.stdin.end();
+      if (options.signal?.aborted)
+        return;
+      try {
+        proc.stdin.end();
+      } catch {}
       await waitForExit(proc);
     } finally {
       options.signal?.removeEventListener("abort", abort6);
@@ -967147,13 +967154,30 @@ class LocalStreamingAudioPlayer {
       proc.kill("SIGTERM");
     } catch {}
   }
+  waitForDrain(timeoutMs) {
+    const proc = this.activeProcess;
+    if (!proc)
+      return Promise.resolve();
+    return new Promise((resolve45) => {
+      let settled = false;
+      const settle = () => {
+        if (settled)
+          return;
+        settled = true;
+        clearTimeout(timer);
+        resolve45();
+      };
+      const timer = setTimeout(settle, timeoutMs);
+      proc.once("close", settle);
+    });
+  }
 }
 function resolveStreamingAudioPlayerCommand(env2 = process.env) {
   const mpv = findExecutable("mpv", env2);
   if (mpv) {
     return {
       command: mpv,
-      args: ["--no-terminal", "--really-quiet", "--force-window=no", "--cache=no", "-"],
+      args: ["--no-terminal", "--really-quiet", "--force-window=no", "-"],
       label: "mpv"
     };
   }
@@ -967161,19 +967185,41 @@ function resolveStreamingAudioPlayerCommand(env2 = process.env) {
   if (ffplay) {
     return {
       command: ffplay,
-      args: ["-nodisp", "-autoexit", "-loglevel", "error", "-i", "pipe:0"],
+      args: FFPLAY_BASE_ARGS,
       label: "ffplay"
     };
   }
   return null;
 }
+var FFPLAY_APAD = ["-af", "apad=pad_dur=0.3"];
+var FFPLAY_BASE_ARGS = ["-nodisp", "-autoexit", "-loglevel", "error", ...FFPLAY_APAD, "-i", "pipe:0"];
 function buildPlayerArgs(command8, format3) {
   if (command8.label !== "ffplay" || !format3)
     return command8.args;
   const normalized3 = format3.trim().toLowerCase();
   if (!normalized3 || normalized3.includes("/"))
     return command8.args;
-  return ["-nodisp", "-autoexit", "-loglevel", "error", "-f", normalized3, "-i", "pipe:0"];
+  return ["-nodisp", "-autoexit", "-loglevel", "error", ...FFPLAY_APAD, "-f", normalized3, "-i", "pipe:0"];
+}
+function awaitReady(proc, signal) {
+  if (signal?.aborted)
+    return Promise.resolve();
+  return new Promise((resolve45, reject) => {
+    let settled = false;
+    const settle = (action2) => {
+      if (settled)
+        return;
+      settled = true;
+      signal?.removeEventListener("abort", onAbort);
+      action2();
+    };
+    const onSpawn = () => settle(resolve45);
+    const onError2 = (error73) => settle(() => reject(error73 instanceof Error ? error73 : new Error(String(error73))));
+    const onAbort = () => settle(resolve45);
+    proc.once("spawn", onSpawn);
+    proc.once("error", onError2);
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
 }
 function findExecutable(name51, env2) {
   const pathValue = env2.PATH ?? "";
@@ -967311,6 +967357,10 @@ function normalizeSpeechText(text) {
 }
 
 // src/audio/spoken-turn-controller.ts
+var SYNTHESIS_PIPELINE_WINDOW = 2;
+var SYNTHESIS_MERGE_MAX_CHARS = 1500;
+var SYNTHESIS_RETRY_DELAYS_MS = [1000, 2500];
+
 class SpokenTurnController {
   pendingPrompt = null;
   activeTurnId = null;
@@ -967320,6 +967370,12 @@ class SpokenTurnController {
   abortControllers = new Set;
   timer = null;
   errorReportedForTurn = false;
+  noPlayerNoticed = false;
+  pendingTexts = [];
+  pipelineDepth = 0;
+  pipelineGeneration = 0;
+  pumpScheduled = false;
+  completedTurnId = null;
   voiceService;
   configManager;
   player;
@@ -967327,6 +967383,8 @@ class SpokenTurnController {
   now;
   setIntervalImpl;
   clearIntervalImpl;
+  setTimeoutImpl;
+  clearTimeoutImpl;
   constructor(options) {
     this.voiceService = options.voiceService;
     this.configManager = options.configManager;
@@ -967335,6 +967393,8 @@ class SpokenTurnController {
     this.now = options.now ?? (() => Date.now());
     this.setIntervalImpl = options.setInterval ?? setInterval;
     this.clearIntervalImpl = options.clearInterval ?? clearInterval;
+    this.setTimeoutImpl = options.setTimeout ?? setTimeout;
+    this.clearTimeoutImpl = options.clearTimeout ?? clearTimeout;
   }
   submitNextTurn(prompt) {
     const normalized3 = prompt.trim();
@@ -967342,26 +967402,46 @@ class SpokenTurnController {
       return false;
     this.stop();
     if (!this.player.available) {
-      this.notify?.("[TTS] Text response will continue, but live audio is unavailable. Install mpv or ffplay.");
+      if (!this.noPlayerNoticed) {
+        this.noPlayerNoticed = true;
+        this.notify?.("[TTS] Text response will continue, but live audio is unavailable. Install mpv or ffplay.");
+      }
       return false;
     }
+    this.noPlayerNoticed = false;
     this.pendingPrompt = normalized3;
     return true;
   }
   stop(message) {
+    const wasActive = this.pendingPrompt !== null || this.activeTurnId !== null || this.chunker !== null || this.abortControllers.size > 0;
     this.pendingPrompt = null;
     this.activeTurnId = null;
     this.chunker?.reset();
     this.chunker = null;
     this.stopTimer();
+    this.resetPipeline();
     for (const controller of this.abortControllers)
       controller.abort();
     this.abortControllers.clear();
     this.player.stop();
     this.playbackChain = Promise.resolve();
     this.errorReportedForTurn = false;
-    if (message)
+    if (message && wasActive)
       this.notify?.(`[TTS] ${message}`);
+    return wasActive;
+  }
+  async stopForExit(drainTimeoutMs = 2000) {
+    this.pendingPrompt = null;
+    this.activeTurnId = null;
+    this.chunker?.reset();
+    this.chunker = null;
+    this.stopTimer();
+    this.resetPipeline();
+    for (const controller of this.abortControllers)
+      controller.abort();
+    this.abortControllers.clear();
+    await this.player.waitForDrain(drainTimeoutMs);
+    this.stop();
   }
   handleTurnEvent(event) {
     if (event.type === "TURN_SUBMITTED") {
@@ -967371,7 +967451,7 @@ class SpokenTurnController {
     if (!this.activeTurnId || event.turnId !== this.activeTurnId)
       return;
     if (event.type === "STREAM_DELTA") {
-      this.enqueueChunks(this.chunker?.push(event.content) ?? []);
+      this.queueTexts(this.chunker?.push(event.content) ?? []);
       return;
     }
     if (event.type === "STREAM_END") {
@@ -967396,29 +967476,30 @@ class SpokenTurnController {
     this.errorReportedForTurn = false;
     this.chunker = new TtsTextChunker({ now: this.now });
     this.playbackChain = Promise.resolve();
+    this.resetPipeline();
     this.startTimer();
     this.notify?.(`[TTS] Live playback queued through ${this.player.label}.`);
   }
   finishTurn(turnId) {
     if (turnId !== this.activeTurnId)
       return;
-    this.enqueueChunks(this.chunker?.flushAll() ?? []);
+    this.queueTexts(this.chunker?.flushAll() ?? []);
     this.stopTimer();
-    const chain4 = this.playbackChain;
-    chain4.finally(() => {
-      if (this.activeTurnId !== turnId)
-        return;
-      this.activeTurnId = null;
-      this.chunker = null;
-      this.abortControllers.clear();
-    }).catch(() => {});
+    this.completedTurnId = turnId;
+    this.maybeReleaseTurn();
+  }
+  resetPipeline() {
+    this.pendingTexts = [];
+    this.pipelineDepth = 0;
+    this.pipelineGeneration++;
+    this.completedTurnId = null;
   }
   startTimer() {
     this.stopTimer();
     this.timer = this.setIntervalImpl(() => {
       if (!this.activeTurnId || !this.chunker)
         return;
-      this.enqueueChunks(this.chunker.flushDue());
+      this.queueTexts(this.chunker.flushDue());
     }, 250);
   }
   stopTimer() {
@@ -967427,42 +967508,136 @@ class SpokenTurnController {
     this.clearIntervalImpl(this.timer);
     this.timer = null;
   }
-  enqueueChunks(chunks) {
+  queueTexts(chunks) {
     for (const chunk of chunks) {
-      this.enqueueChunk(chunk);
+      if (chunk.trim())
+        this.pendingTexts.push(chunk);
+    }
+    if (this.pendingTexts.length > 0)
+      this.schedulePump();
+  }
+  schedulePump() {
+    if (this.pumpScheduled)
+      return;
+    this.pumpScheduled = true;
+    queueMicrotask(() => {
+      this.pumpScheduled = false;
+      this.pump();
+    });
+  }
+  pump() {
+    while (this.activeTurnId && this.pendingTexts.length > 0 && this.pipelineDepth < SYNTHESIS_PIPELINE_WINDOW) {
+      this.dispatchChunk(this.takeMergedText());
+    }
+    this.maybeReleaseTurn();
+  }
+  takeMergedText() {
+    let merged = "";
+    while (this.pendingTexts.length > 0) {
+      const next = this.pendingTexts[0];
+      if (!merged && next.length > SYNTHESIS_MERGE_MAX_CHARS) {
+        const cut = findSplitIndex(next, SYNTHESIS_MERGE_MAX_CHARS);
+        this.pendingTexts[0] = next.slice(cut).trim();
+        return next.slice(0, cut).trim();
+      }
+      if (merged && merged.length + 1 + next.length > SYNTHESIS_MERGE_MAX_CHARS)
+        break;
+      merged = merged ? `${merged} ${next}` : next;
+      this.pendingTexts.shift();
     }
+    return merged;
   }
-  enqueueChunk(text) {
+  dispatchChunk(text) {
     const turnId = this.activeTurnId;
     if (!turnId || !text.trim())
       return;
     const sequence = ++this.chunkSequence;
+    const generation = this.pipelineGeneration;
+    this.pipelineDepth++;
     const abortController = new AbortController;
     this.abortControllers.add(abortController);
-    const resultPromise = this.synthesize(text, turnId, sequence, abortController.signal).then((result2) => ({ ok: true, result: result2 })).catch((error73) => ({ ok: false, error: error73 }));
+    const resultPromise = this.synthesizeWithRetry(text, turnId, sequence, abortController.signal).then((result2) => ({ ok: true, result: result2 })).catch((error73) => ({ ok: false, error: error73 }));
     this.playbackChain = this.playbackChain.then(async () => {
-      if (abortController.signal.aborted)
-        return;
-      const result2 = await resultPromise;
-      this.abortControllers.delete(abortController);
-      if (!result2.ok) {
-        this.reportError(result2.error);
-        return;
+      try {
+        if (abortController.signal.aborted) {
+          this.abortControllers.delete(abortController);
+          return;
+        }
+        const result2 = await resultPromise;
+        this.abortControllers.delete(abortController);
+        if (abortController.signal.aborted)
+          return;
+        if (!result2.ok) {
+          this.reportSkippedChunk(result2.error);
+          return;
+        }
+        await this.player.play(result2.result.chunks, {
+          format: String(result2.result.format ?? "mp3"),
+          signal: abortController.signal
+        });
+      } finally {
+        this.releasePipelineSlot(generation);
       }
-      await this.player.play(result2.result.chunks, {
-        format: String(result2.result.format ?? "mp3"),
-        signal: abortController.signal
-      });
     }).catch((error73) => {
       this.abortControllers.delete(abortController);
       this.reportError(error73);
     });
   }
+  releasePipelineSlot(generation) {
+    if (generation !== this.pipelineGeneration)
+      return;
+    this.pipelineDepth = Math.max(0, this.pipelineDepth - 1);
+    if (this.pendingTexts.length > 0) {
+      this.schedulePump();
+      return;
+    }
+    this.maybeReleaseTurn();
+  }
+  maybeReleaseTurn() {
+    if (!this.completedTurnId || this.completedTurnId !== this.activeTurnId)
+      return;
+    if (this.pendingTexts.length > 0 || this.pipelineDepth > 0 || this.pumpScheduled)
+      return;
+    this.activeTurnId = null;
+    this.completedTurnId = null;
+    this.chunker = null;
+    this.abortControllers.clear();
+  }
+  async synthesizeWithRetry(text, turnId, sequence, signal) {
+    for (let attempt = 0;; attempt++) {
+      try {
+        return await this.synthesize(text, turnId, sequence, signal);
+      } catch (error73) {
+        const retryable = attempt < SYNTHESIS_RETRY_DELAYS_MS.length && !signal.aborted && isTransientSynthesisError(error73);
+        if (!retryable)
+          throw error73;
+        await this.delay(SYNTHESIS_RETRY_DELAYS_MS[attempt], signal);
+      }
+    }
+  }
+  delay(ms, signal) {
+    return new Promise((resolve45, reject) => {
+      if (signal.aborted) {
+        reject(new Error("Synthesis retry cancelled"));
+        return;
+      }
+      const timer = this.setTimeoutImpl(() => {
+        signal.removeEventListener("abort", onAbort);
+        resolve45();
+      }, ms);
+      const onAbort = () => {
+        this.clearTimeoutImpl(timer);
+        reject(new Error("Synthesis retry cancelled"));
+      };
+      signal.addEventListener("abort", onAbort, { once: true });
+    });
+  }
   synthesize(text, turnId, sequence, signal) {
     return this.voiceService.synthesizeStream(readOptionalConfigString2(this.configManager, "tts.provider"), {
       text,
       voiceId: readOptionalConfigString2(this.configManager, "tts.voice"),
       format: "mp3",
+      speed: readOptionalConfigNumber(this.configManager, "tts.speed"),
       signal,
       metadata: {
         source: "goodvibes-agent",
@@ -967472,6 +967647,12 @@ class SpokenTurnController {
       }
     });
   }
+  reportSkippedChunk(error73) {
+    if (this.errorReportedForTurn)
+      return;
+    this.errorReportedForTurn = true;
+    this.notify?.(`[TTS] Skipping part of the spoken response \u2014 synthesis kept failing (${summarizeError(error73)}). Playback continues with the rest.`);
+  }
   reportError(error73) {
     if (this.errorReportedForTurn)
       return;
@@ -967479,6 +967660,7 @@ class SpokenTurnController {
     this.activeTurnId = null;
     this.chunker = null;
     this.stopTimer();
+    this.resetPipeline();
     for (const controller of this.abortControllers)
       controller.abort();
     this.abortControllers.clear();
@@ -967487,17 +967669,35 @@ class SpokenTurnController {
     this.notify?.(`[TTS] Live playback stopped: ${summarizeError(error73)}`);
   }
 }
+function isTransientSynthesisError(error73) {
+  const message = (error73 instanceof Error ? error73.message : String(error73)).toLowerCase();
+  if (message.includes("429") || message.includes("rate limit") || message.includes("rate_limit") || message.includes("too many requests") || message.includes("concurrent"))
+    return true;
+  if (/http 5\d\d/.test(message))
+    return true;
+  return message.includes("fetch failed") || message.includes("network") || message.includes("timed out") || message.includes("timeout") || message.includes("econnreset") || message.includes("socket");
+}
+function findSplitIndex(text, limit3) {
+  const space = text.lastIndexOf(" ", limit3);
+  return space > 0 ? space : limit3;
+}
 function readOptionalConfigString2(configManager, key) {
   const value = String(configManager.get(key) ?? "").trim();
   return value || undefined;
 }
+function readOptionalConfigNumber(configManager, key) {
+  const raw = configManager.get(key);
+  const value = typeof raw === "number" ? raw : parseFloat(String(raw ?? ""));
+  return isFinite(value) && value > 0 ? value : undefined;
+}
 
 // src/audio/spoken-turn-wiring.ts
 function wireSpokenTurnRuntime(options) {
+  const player = options.playerFactory ? options.playerFactory() : new LocalStreamingAudioPlayer;
   const controller = new SpokenTurnController({
     voiceService: options.voiceService,
     configManager: options.configManager,
-    player: new LocalStreamingAudioPlayer,
+    player,
     notify: options.notify
   });
   const turns = options.events.turns;
@@ -967513,7 +967713,35 @@ function wireSpokenTurnRuntime(options) {
   return {
     unsubs,
     submitNextTurn: (prompt) => controller.submitNextTurn(prompt),
-    stop: (message) => controller.stop(message)
+    stop: (message) => controller.stop(message),
+    stopForExit: (drainTimeoutMs) => controller.stopForExit(drainTimeoutMs)
+  };
+}
+
+// src/runtime/unhandled-rejection-guard.ts
+function createUnhandledRejectionHandler(deps) {
+  let rejectionCount = 0;
+  let windowStart = Date.now();
+  return (reason) => {
+    const now5 = Date.now();
+    if (now5 - windowStart > 1e4) {
+      rejectionCount = 0;
+      windowStart = now5;
+    }
+    rejectionCount++;
+    const msg = reason instanceof Error ? reason.message : String(reason);
+    if (rejectionCount > 3) {
+      logger.error("CRITICAL: cascading unhandled rejections \u2014 consider restarting", {
+        count: rejectionCount,
+        windowMs: now5 - windowStart,
+        error: String(reason)
+      });
+      deps.notifyHigh(`[Critical] Multiple errors detected (${rejectionCount} in 10s). If the issue persists, please restart. Latest: ${msg}`);
+    } else {
+      deps.notifyHigh(`[Error] ${msg}`);
+      logger.error("unhandledRejection", { error: String(reason) });
+    }
+    deps.render();
   };
 }
 
@@ -968043,36 +968271,26 @@ async function main() {
   let stopSpokenOutputForExit = null;
   let recoveryPending = false;
   const sigintHandler = () => input.feed("\x03");
-  let _unhandledRejectionCount = 0;
-  let _unhandledRejectionWindowStart = Date.now();
-  const unhandledRejectionHandler = (reason) => {
-    const now5 = Date.now();
-    if (now5 - _unhandledRejectionWindowStart > 1e4) {
-      _unhandledRejectionCount = 0;
-      _unhandledRejectionWindowStart = now5;
-    }
-    _unhandledRejectionCount++;
-    const msg = reason instanceof Error ? reason.message : String(reason);
-    if (_unhandledRejectionCount > 3) {
-      logger.error("CRITICAL: cascading unhandled rejections \u2014 consider restarting", {
-        count: _unhandledRejectionCount,
-        windowMs: now5 - _unhandledRejectionWindowStart,
-        error: String(reason)
-      });
-      systemMessageRouter.high(`[Critical] Multiple errors detected (${_unhandledRejectionCount} in 10s). If the issue persists, please restart. Latest: ${msg}`);
-    } else {
-      systemMessageRouter.high(`[Error] ${msg}`);
-      logger.error("unhandledRejection", { error: String(reason) });
-    }
-    render();
-  };
+  const unhandledRejectionHandler = createUnhandledRejectionHandler({
+    notifyHigh: (message) => systemMessageRouter.high(message),
+    render: () => render()
+  });
   const resizeHandler = () => {
     input.setContentWidth(getPromptContentWidth());
     compositor.resetDiff();
     render();
   };
+  let exiting = false;
   const exitApp = () => {
-    stopSpokenOutputForExit?.();
+    if (exiting)
+      return;
+    exiting = true;
+    let spokenOutputDrain = Promise.resolve();
+    try {
+      spokenOutputDrain = Promise.resolve(stopSpokenOutputForExit?.()).then(() => {
+        return;
+      });
+    } catch {}
     unsubs.forEach((fn) => fn());
     autonomy.stop();
     const snapshot2 = buildCurrentSessionSnapshot();
@@ -968092,7 +968310,9 @@ async function main() {
     allowTerminalWrite(() => stdout.write(PASTE_DISABLE + KEYBOARD_EXT_DISABLE2 + MOUSE_DISABLE + FOCUS_DISABLE + CURSOR_SHOW + exitScreen));
     terminalOutputGuard.dispose();
     stdin.setRawMode(false);
-    process.exit(0);
+    spokenOutputDrain.catch(() => {
+      return;
+    }).then(() => process.exit(0));
   };
   commandContext.exit = exitApp;
   const spokenTurns = wireSpokenTurnRuntime({
@@ -968104,7 +968324,7 @@ async function main() {
       render();
     }
   });
-  stopSpokenOutputForExit = () => spokenTurns.stop();
+  stopSpokenOutputForExit = () => spokenTurns.stopForExit();
   unsubs.push(...spokenTurns.unsubs);
   unsubs.push(attachSpokenTurnModelRouting({
     orchestrator,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pellux/goodvibes-agent",
-  "version": "1.5.8",
+  "version": "1.5.9",
   "private": false,
   "description": "GoodVibes personal operator assistant TUI with a proactive Agent product brain, isolated Agent Knowledge, local profiles, routines, skills, personas, and explicit build delegation.",
   "type": "module",