@pellux/goodvibes-tui 0.20.3 → 0.22.0

package/src/audio/spoken-turn-controller.ts

@@ -25,6 +25,7 @@ export class SpokenTurnController {
   private readonly abortControllers = new Set<AbortController>();
   private timer: ReturnType<typeof setInterval> | null = null;
   private errorReportedForTurn = false;
+  private noPlayerNoticed = false;
   private readonly voiceService: Pick<VoiceService, 'synthesizeStream'>;
   private readonly configManager: Pick<ConfigManager, 'get'>;
   private readonly player: StreamingAudioPlayer;
@@ -48,9 +49,14 @@ export class SpokenTurnController {
     if (!normalized) 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;
     }
+    // Reset the no-player notice if player becomes available again.
+    this.noPlayerNoticed = false;
     this.pendingPrompt = normalized;
     return true;
   }
@@ -169,10 +175,15 @@ export class SpokenTurnController {
   }
 
   private synthesize(text: string, turnId: string, sequence: number, signal: AbortSignal): Promise<VoiceSynthesisStreamResult> {
+    // tts.speed: VoiceSynthesisRequest accepts speed (number | undefined).
+    // No ConfigKey for tts.speed exists in the current SDK schema — pending
+    // SDK schema addition. Speed is not threaded from config until that key
+    // is added. See docs/voice-and-live-tts.md § Speed.
     return this.voiceService.synthesizeStream(readOptionalConfigString(this.configManager, 'tts.provider'), {
       text,
       voiceId: readOptionalConfigString(this.configManager, 'tts.voice'),
       format: 'mp3',
+      speed: readOptionalConfigNumber(this.configManager, 'tts.speed'),
       signal,
       metadata: {
         source: 'goodvibes-tui',
@@ -201,3 +212,22 @@ function readOptionalConfigString(configManager: Pick<ConfigManager, 'get'>, key
   const value = String(configManager.get(key) ?? '').trim();
   return value || undefined;
 }
+
+/**
+ * readOptionalConfigNumber — reads a numeric config value by key.
+ *
+ * `tts.speed` is not yet a ConfigKey in the SDK schema. This helper accepts
+ * a string key and casts it, returning undefined when the value is absent,
+ * zero, or not a finite positive number. Once `tts.speed` is added to the
+ * SDK schema the cast can be removed and the key typed statically.
+ *
+ * SDK handoff note: add { key: 'tts.speed', type: 'number', default: 1,
+ * description: '...' } to schema-domain-core.js and `tts: { ..., speed: 1 }`
+ * to DEFAULT_CONFIG.tts to complete this feature.
+ */
+function readOptionalConfigNumber(configManager: Pick<ConfigManager, 'get'>, key: string): number | undefined {
+  // Cast required: key is not yet a valid ConfigKey in the SDK schema.
+  const raw = configManager.get(key as ConfigKey);
+  const value = typeof raw === 'number' ? raw : parseFloat(String(raw ?? ''));
+  return isFinite(value) && value > 0 ? value : undefined;
+}

package/src/audio/spoken-turn-wiring.ts

@@ -1,6 +1,7 @@
 import type { ConfigManager } from '@pellux/goodvibes-sdk/platform/config';
 import type { UiRuntimeEvents } from '@/runtime/index.ts';
 import type { VoiceService } from '@pellux/goodvibes-sdk/platform/voice';
+import type { StreamingAudioPlayer } from './player.ts';
 import { LocalStreamingAudioPlayer } from './player.ts';
 import { SpokenTurnController } from './spoken-turn-controller.ts';
 
@@ -11,23 +12,44 @@ export interface SpokenTurnRuntime {
 }
 
 export interface WireSpokenTurnRuntimeOptions {
-  readonly voiceService: VoiceService;
-  readonly configManager: ConfigManager;
+  readonly voiceService: Pick<VoiceService, 'synthesizeStream'>;
+  readonly configManager: Pick<ConfigManager, 'get'>;
   readonly events: UiRuntimeEvents;
   readonly notify: (message: string) => void;
+  /**
+   * Optional player factory — injected in tests to avoid spawning real
+   * subprocesses. Defaults to LocalStreamingAudioPlayer.
+   */
+  readonly playerFactory?: () => StreamingAudioPlayer;
 }
 
+/**
+ * wireSpokenTurnRuntime — wires the spoken-turn pipeline against the runtime
+ * event bus.
+ *
+ * Always-speak mode: when `ui.voiceEnabled` is true in config, every
+ * TURN_SUBMITTED event arms the turn for spoken output automatically — the
+ * user does not need to prefix the prompt with /tts. The availability check
+ * inside SpokenTurnController still gates gracefully when no player is found.
+ */
 export function wireSpokenTurnRuntime(options: WireSpokenTurnRuntimeOptions): SpokenTurnRuntime {
+  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;
   const unsubs = [
-    turns.on('TURN_SUBMITTED', (event) => controller.handleTurnEvent(event)),
+    turns.on('TURN_SUBMITTED', (event) => {
+      // Always-speak mode: auto-arm when ui.voiceEnabled is set.
+      if (options.configManager.get('ui.voiceEnabled')) {
+        controller.submitNextTurn(event.prompt);
+      }
+      controller.handleTurnEvent(event);
+    }),
     turns.on('PREFLIGHT_FAIL', (event) => controller.handleTurnEvent(event)),
     turns.on('STREAM_DELTA', (event) => controller.handleTurnEvent(event)),
     turns.on('STREAM_END', (event) => controller.handleTurnEvent(event)),

package/src/cli/bundle-command.ts

@@ -9,7 +9,7 @@ import { getOnboardingCheckMarkerPath } from '../runtime/onboarding/index.ts';
 import { CONFIG_SCHEMA } from '../config/index.ts';
 import { SecretsManager } from '../config/secrets.ts';
 import type { ConfigKey } from '../config/index.ts';
-import type { CliCommandRuntime } from './management.ts';
+import type { CliCommandRuntime } from './types.ts';
 import type { CliCommandOutput } from './types.ts';
 import { getPackageVersion } from './help.ts';
 import { classifyProviderSetup } from './provider-classification.ts';