@pellux/goodvibes-tui 0.19.30 → 0.19.32

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pellux/goodvibes-tui",
-  "version": "0.19.30",
+  "version": "0.19.32",
   "description": "Terminal-native GoodVibes product for coding, operations, automation, knowledge, channels, and daemon-backed control-plane workflows.",
   "type": "module",
   "main": "src/main.ts",
@@ -91,7 +91,7 @@
     "@anthropic-ai/vertex-sdk": "^0.16.0",
     "@ast-grep/napi": "^0.42.0",
     "@aws/bedrock-token-generator": "^1.1.0",
-    "@pellux/goodvibes-sdk": "^0.25.5",
+    "@pellux/goodvibes-sdk": "0.25.8",
     "bash-language-server": "^5.6.0",
     "fuse.js": "^7.1.0",
     "graphql": "^16.13.2",

package/src/audio/player.ts

@@ -0,0 +1,156 @@
+import { accessSync, constants } from 'node:fs';
+import { delimiter, join } from 'node:path';
+import { spawn } from 'node:child_process';
+import type { Writable } from 'node:stream';
+import type { VoiceAudioChunk } from '@pellux/goodvibes-sdk/platform/voice/index';
+
+export interface StreamingAudioPlayerCommand {
+  readonly command: string;
+  readonly args: readonly string[];
+  readonly label: string;
+}
+
+export interface StreamingAudioPlayer {
+  readonly label: string;
+  readonly available: boolean;
+  play(chunks: AsyncIterable<VoiceAudioChunk>, options: StreamingAudioPlaybackOptions): Promise<void>;
+  stop(): void;
+}
+
+export interface StreamingAudioPlaybackOptions {
+  readonly format?: string;
+  readonly signal?: AbortSignal;
+}
+
+interface SpawnProcess {
+  readonly stdin: Writable;
+  once(event: 'close', listener: () => void): this;
+  kill(signal?: NodeJS.Signals | number): boolean;
+}
+type SpawnProcessFactory = (command: string, args: readonly string[]) => SpawnProcess;
+
+export interface LocalStreamingAudioPlayerOptions {
+  readonly env?: NodeJS.ProcessEnv;
+  readonly spawnProcess?: SpawnProcessFactory;
+}
+
+export class LocalStreamingAudioPlayer implements StreamingAudioPlayer {
+  readonly command: StreamingAudioPlayerCommand | null;
+  private activeProcess: SpawnProcess | null = null;
+  private readonly spawnProcess: SpawnProcessFactory;
+
+  constructor(options: LocalStreamingAudioPlayerOptions = {}) {
+    this.command = resolveStreamingAudioPlayerCommand(options.env ?? process.env);
+    this.spawnProcess = options.spawnProcess ?? defaultSpawnProcess;
+  }
+
+  get label(): string {
+    return this.command?.label ?? 'no streaming audio player found';
+  }
+
+  get available(): boolean {
+    return this.command !== null;
+  }
+
+  async play(chunks: AsyncIterable<VoiceAudioChunk>, options: StreamingAudioPlaybackOptions = {}): Promise<void> {
+    if (!this.command) {
+      throw new Error('No streaming audio player found. Install mpv or ffplay to use /tts live playback.');
+    }
+    if (options.signal?.aborted) return;
+
+    const proc = this.spawnProcess(this.command.command, buildPlayerArgs(this.command, options.format));
+    this.activeProcess = proc;
+    const abort = () => {
+      try { proc.stdin.destroy(); } catch { /* ignore */ }
+      try { proc.kill('SIGTERM'); } catch { /* ignore */ }
+    };
+    options.signal?.addEventListener('abort', abort, { once: true });
+
+    try {
+      for await (const chunk of chunks) {
+        if (options.signal?.aborted) break;
+        if (chunk.data.byteLength === 0) continue;
+        await writeStdin(proc, chunk.data);
+      }
+      proc.stdin.end();
+      await waitForExit(proc);
+    } finally {
+      options.signal?.removeEventListener('abort', abort);
+      if (this.activeProcess === proc) this.activeProcess = null;
+    }
+  }
+
+  stop(): void {
+    const proc = this.activeProcess;
+    this.activeProcess = null;
+    if (!proc) return;
+    try { proc.stdin.destroy(); } catch { /* ignore */ }
+    try { proc.kill('SIGTERM'); } catch { /* ignore */ }
+  }
+}
+
+export function resolveStreamingAudioPlayerCommand(env: NodeJS.ProcessEnv = process.env): StreamingAudioPlayerCommand | null {
+  const mpv = findExecutable('mpv', env);
+  if (mpv) {
+    return {
+      command: mpv,
+      args: ['--no-terminal', '--really-quiet', '--force-window=no', '--cache=no', '-'],
+      label: 'mpv',
+    };
+  }
+  const ffplay = findExecutable('ffplay', env);
+  if (ffplay) {
+    return {
+      command: ffplay,
+      args: ['-nodisp', '-autoexit', '-loglevel', 'error', '-i', 'pipe:0'],
+      label: 'ffplay',
+    };
+  }
+  return null;
+}
+
+function buildPlayerArgs(command: StreamingAudioPlayerCommand, format?: string): readonly string[] {
+  if (command.label !== 'ffplay' || !format) return command.args;
+  const normalized = format.trim().toLowerCase();
+  if (!normalized || normalized.includes('/')) return command.args;
+  return ['-nodisp', '-autoexit', '-loglevel', 'error', '-f', normalized, '-i', 'pipe:0'];
+}
+
+function findExecutable(name: string, env: NodeJS.ProcessEnv): string | null {
+  const pathValue = env.PATH ?? '';
+  const extensions = process.platform === 'win32'
+    ? ['', '.exe', '.cmd', '.bat']
+    : [''];
+  for (const dir of pathValue.split(delimiter)) {
+    if (!dir) continue;
+    for (const ext of extensions) {
+      const candidate = join(dir, `${name}${ext}`);
+      try {
+        accessSync(candidate, constants.X_OK);
+        return candidate;
+      } catch {
+        // Keep scanning PATH.
+      }
+    }
+  }
+  return null;
+}
+
+function defaultSpawnProcess(command: string, args: readonly string[]): SpawnProcess {
+  return spawn(command, [...args], { stdio: ['pipe', 'ignore', 'ignore'] });
+}
+
+function writeStdin(proc: SpawnProcess, data: Uint8Array): Promise<void> {
+  return new Promise((resolve, reject) => {
+    proc.stdin.write(Buffer.from(data), (error) => {
+      if (error) reject(error);
+      else resolve();
+    });
+  });
+}
+
+function waitForExit(proc: SpawnProcess): Promise<void> {
+  return new Promise((resolve) => {
+    proc.once('close', () => resolve());
+  });
+}

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

@@ -0,0 +1,200 @@
+import type { ConfigManager } from '@pellux/goodvibes-sdk/platform/config/manager';
+import type { ConfigKey } from '@pellux/goodvibes-sdk/platform/config/schema';
+import type { TurnEvent } from '@pellux/goodvibes-sdk/platform/runtime/events/index';
+import type { VoiceService, VoiceSynthesisStreamResult } from '@pellux/goodvibes-sdk/platform/voice/index';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils/error-display';
+import { TtsTextChunker } from './text-chunker.ts';
+import type { StreamingAudioPlayer } from './player.ts';
+
+export interface SpokenTurnControllerOptions {
+  readonly voiceService: Pick<VoiceService, 'synthesizeStream'>;
+  readonly configManager: Pick<ConfigManager, 'get'>;
+  readonly player: StreamingAudioPlayer;
+  readonly notify?: (message: string) => void;
+  readonly now?: () => number;
+  readonly setInterval?: typeof setInterval;
+  readonly clearInterval?: typeof clearInterval;
+}
+
+export class SpokenTurnController {
+  private pendingPrompt: string | null = null;
+  private activeTurnId: string | null = null;
+  private chunker: TtsTextChunker | null = null;
+  private chunkSequence = 0;
+  private playbackChain: Promise<void> = Promise.resolve();
+  private readonly abortControllers = new Set<AbortController>();
+  private timer: ReturnType<typeof setInterval> | null = null;
+  private errorReportedForTurn = false;
+  private readonly voiceService: Pick<VoiceService, 'synthesizeStream'>;
+  private readonly configManager: Pick<ConfigManager, 'get'>;
+  private readonly player: StreamingAudioPlayer;
+  private readonly notify?: (message: string) => void;
+  private readonly now: () => number;
+  private readonly setIntervalImpl: typeof setInterval;
+  private readonly clearIntervalImpl: typeof clearInterval;
+
+  constructor(options: SpokenTurnControllerOptions) {
+    this.voiceService = options.voiceService;
+    this.configManager = options.configManager;
+    this.player = options.player;
+    this.notify = options.notify;
+    this.now = options.now ?? (() => Date.now());
+    this.setIntervalImpl = options.setInterval ?? setInterval;
+    this.clearIntervalImpl = options.clearInterval ?? clearInterval;
+  }
+
+  submitNextTurn(prompt: string): boolean {
+    const normalized = prompt.trim();
+    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.');
+      return false;
+    }
+    this.pendingPrompt = normalized;
+    return true;
+  }
+
+  stop(message?: string): void {
+    this.pendingPrompt = null;
+    this.activeTurnId = null;
+    this.chunker?.reset();
+    this.chunker = null;
+    this.stopTimer();
+    for (const controller of this.abortControllers) controller.abort();
+    this.abortControllers.clear();
+    this.player.stop();
+    this.playbackChain = Promise.resolve();
+    this.errorReportedForTurn = false;
+    if (message) this.notify?.(`[TTS] ${message}`);
+  }
+
+  handleTurnEvent(event: TurnEvent): void {
+    if (event.type === 'TURN_SUBMITTED') {
+      this.maybeStartTurn(event.turnId, event.prompt);
+      return;
+    }
+    if (!this.activeTurnId || event.turnId !== this.activeTurnId) return;
+
+    if (event.type === 'STREAM_DELTA') {
+      this.enqueueChunks(this.chunker?.push(event.content) ?? []);
+      return;
+    }
+    if (event.type === 'STREAM_END' || event.type === 'TURN_COMPLETED') {
+      this.finishTurn(event.turnId);
+      return;
+    }
+    if (event.type === 'TURN_CANCEL' || event.type === 'TURN_ERROR' || event.type === 'PREFLIGHT_FAIL') {
+      this.stop(event.type === 'TURN_CANCEL' ? 'Spoken output stopped.' : 'Spoken output stopped because the turn did not complete.');
+    }
+  }
+
+  private maybeStartTurn(turnId: string, prompt: string): void {
+    if (!this.pendingPrompt) return;
+    if (prompt.trim() !== this.pendingPrompt) return;
+    this.pendingPrompt = null;
+    this.activeTurnId = turnId;
+    this.chunkSequence = 0;
+    this.errorReportedForTurn = false;
+    this.chunker = new TtsTextChunker({ now: this.now });
+    this.playbackChain = Promise.resolve();
+    this.startTimer();
+    this.notify?.(`[TTS] Live playback queued through ${this.player.label}.`);
+  }
+
+  private finishTurn(turnId: string): void {
+    if (turnId !== this.activeTurnId) return;
+    this.enqueueChunks(this.chunker?.flushAll() ?? []);
+    this.stopTimer();
+    const chain = this.playbackChain;
+    chain.finally(() => {
+      if (this.activeTurnId !== turnId) return;
+      this.activeTurnId = null;
+      this.chunker = null;
+      this.abortControllers.clear();
+    }).catch(() => {
+      // Errors are already reported in the queued task.
+    });
+  }
+
+  private startTimer(): void {
+    this.stopTimer();
+    this.timer = this.setIntervalImpl(() => {
+      if (!this.activeTurnId || !this.chunker) return;
+      this.enqueueChunks(this.chunker.flushDue());
+    }, 250);
+  }
+
+  private stopTimer(): void {
+    if (!this.timer) return;
+    this.clearIntervalImpl(this.timer);
+    this.timer = null;
+  }
+
+  private enqueueChunks(chunks: readonly string[]): void {
+    for (const chunk of chunks) {
+      this.enqueueChunk(chunk);
+    }
+  }
+
+  private enqueueChunk(text: string): void {
+    const turnId = this.activeTurnId;
+    if (!turnId || !text.trim()) return;
+    const sequence = ++this.chunkSequence;
+    const abortController = new AbortController();
+    this.abortControllers.add(abortController);
+    const resultPromise = this.synthesize(text, turnId, sequence, abortController.signal)
+      .then((result) => ({ ok: true as const, result }))
+      .catch((error: unknown) => ({ ok: false as const, error }));
+
+    this.playbackChain = this.playbackChain.then(async () => {
+      if (abortController.signal.aborted) return;
+      const result = await resultPromise;
+      this.abortControllers.delete(abortController);
+      if (!result.ok) {
+        this.reportError(result.error);
+        return;
+      }
+      await this.player.play(result.result.chunks, {
+        format: String(result.result.format ?? 'mp3'),
+        signal: abortController.signal,
+      });
+    }).catch((error: unknown) => {
+      this.abortControllers.delete(abortController);
+      this.reportError(error);
+    });
+  }
+
+  private synthesize(text: string, turnId: string, sequence: number, signal: AbortSignal): Promise<VoiceSynthesisStreamResult> {
+    return this.voiceService.synthesizeStream(readOptionalConfigString(this.configManager, 'tts.provider'), {
+      text,
+      voiceId: readOptionalConfigString(this.configManager, 'tts.voice'),
+      format: 'mp3',
+      signal,
+      metadata: {
+        source: 'goodvibes-tui',
+        feature: 'live-tts',
+        turnId,
+        sequence,
+      },
+    });
+  }
+
+  private reportError(error: unknown): void {
+    if (this.errorReportedForTurn) return;
+    this.errorReportedForTurn = true;
+    this.activeTurnId = null;
+    this.chunker = null;
+    this.stopTimer();
+    for (const controller of this.abortControllers) controller.abort();
+    this.abortControllers.clear();
+    this.player.stop();
+    this.playbackChain = Promise.resolve();
+    this.notify?.(`[TTS] Live playback stopped: ${summarizeError(error)}`);
+  }
+}
+
+function readOptionalConfigString(configManager: Pick<ConfigManager, 'get'>, key: ConfigKey): string | undefined {
+  const value = String(configManager.get(key) ?? '').trim();
+  return value || undefined;
+}

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

@@ -0,0 +1,44 @@
+import type { ConfigManager } from '@pellux/goodvibes-sdk/platform/config/manager';
+import type { UiRuntimeEvents } from '@pellux/goodvibes-sdk/platform/runtime/ui-events';
+import type { VoiceService } from '@pellux/goodvibes-sdk/platform/voice/index';
+import { LocalStreamingAudioPlayer } from './player.ts';
+import { SpokenTurnController } from './spoken-turn-controller.ts';
+
+export interface SpokenTurnRuntime {
+  readonly unsubs: readonly (() => void)[];
+  submitNextTurn(prompt: string): boolean;
+  stop(message?: string): void;
+}
+
+export interface WireSpokenTurnRuntimeOptions {
+  readonly voiceService: VoiceService;
+  readonly configManager: ConfigManager;
+  readonly events: UiRuntimeEvents;
+  readonly notify: (message: string) => void;
+}
+
+export function wireSpokenTurnRuntime(options: WireSpokenTurnRuntimeOptions): SpokenTurnRuntime {
+  const controller = new SpokenTurnController({
+    voiceService: options.voiceService,
+    configManager: options.configManager,
+    player: new LocalStreamingAudioPlayer(),
+    notify: options.notify,
+  });
+
+  const turns = options.events.turns;
+  const unsubs = [
+    turns.on('TURN_SUBMITTED', (event) => 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)),
+    turns.on('TURN_COMPLETED', (event) => controller.handleTurnEvent(event)),
+    turns.on('TURN_ERROR', (event) => controller.handleTurnEvent(event)),
+    turns.on('TURN_CANCEL', (event) => controller.handleTurnEvent(event)),
+  ];
+
+  return {
+    unsubs,
+    submitNextTurn: (prompt) => controller.submitNextTurn(prompt),
+    stop: (message) => controller.stop(message),
+  };
+}

package/src/audio/text-chunker.ts

@@ -0,0 +1,110 @@
+export interface TtsTextChunkerOptions {
+  readonly minBoundaryChars?: number;
+  readonly maxChunkChars?: number;
+  readonly maxLatencyMs?: number;
+  readonly now?: () => number;
+}
+
+export class TtsTextChunker {
+  private buffer = '';
+  private firstBufferedAt: number | null = null;
+  private readonly minBoundaryChars: number;
+  private readonly maxChunkChars: number;
+  private readonly maxLatencyMs: number;
+  private readonly now: () => number;
+
+  constructor(options: TtsTextChunkerOptions = {}) {
+    this.minBoundaryChars = options.minBoundaryChars ?? 24;
+    this.maxChunkChars = options.maxChunkChars ?? 320;
+    this.maxLatencyMs = options.maxLatencyMs ?? 1_000;
+    this.now = options.now ?? (() => Date.now());
+  }
+
+  push(delta: string): string[] {
+    if (!delta) return [];
+    if (this.firstBufferedAt === null) this.firstBufferedAt = this.now();
+    this.buffer += delta;
+    return this.drainReady(false);
+  }
+
+  flushDue(): string[] {
+    if (!this.buffer.trim() || this.firstBufferedAt === null) return [];
+    if (this.now() - this.firstBufferedAt < this.maxLatencyMs) return [];
+    return this.drainReady(true);
+  }
+
+  flushAll(): string[] {
+    if (!this.buffer.trim()) {
+      this.buffer = '';
+      this.firstBufferedAt = null;
+      return [];
+    }
+    return [this.takeChunk(this.buffer.length)].filter(Boolean);
+  }
+
+  reset(): void {
+    this.buffer = '';
+    this.firstBufferedAt = null;
+  }
+
+  private drainReady(forceLatencyFlush: boolean): string[] {
+    const chunks: string[] = [];
+    while (this.buffer.trim()) {
+      const boundary = this.findBoundary(forceLatencyFlush);
+      if (boundary <= 0) break;
+      const chunk = this.takeChunk(boundary);
+      if (chunk) chunks.push(chunk);
+      forceLatencyFlush = false;
+    }
+    return chunks;
+  }
+
+  private findBoundary(forceLatencyFlush: boolean): number {
+    const latestSentence = this.findLatestSentenceBoundary();
+    if (latestSentence >= this.minBoundaryChars) return latestSentence;
+
+    if (this.buffer.length >= this.maxChunkChars) {
+      return this.findWordBoundaryBefore(this.maxChunkChars) || this.maxChunkChars;
+    }
+
+    if (forceLatencyFlush) {
+      return this.buffer.length;
+    }
+
+    return -1;
+  }
+
+  private findLatestSentenceBoundary(): number {
+    let best = -1;
+    for (let i = 0; i < this.buffer.length; i++) {
+      const char = this.buffer[i];
+      if (char !== '.' && char !== '!' && char !== '?' && char !== ';' && char !== ':' && char !== '\n') {
+        continue;
+      }
+      const next = this.buffer[i + 1];
+      if (i === this.buffer.length - 1 || next === undefined || /\s/.test(next)) {
+        best = i + 1;
+      }
+    }
+    return best;
+  }
+
+  private findWordBoundaryBefore(index: number): number {
+    const max = Math.min(index, this.buffer.length);
+    for (let i = max; i > 0; i--) {
+      if (/\s/.test(this.buffer[i - 1] ?? '')) return i;
+    }
+    return -1;
+  }
+
+  private takeChunk(end: number): string {
+    const raw = this.buffer.slice(0, end);
+    this.buffer = this.buffer.slice(end);
+    this.firstBufferedAt = this.buffer.trim() ? this.now() : null;
+    return normalizeSpeechText(raw);
+  }
+}
+
+export function normalizeSpeechText(text: string): string {
+  return text.replace(/\s+/g, ' ').trim();
+}

package/src/cli/management.ts

@@ -21,6 +21,7 @@ import { inspectProviderAuth } from '@pellux/goodvibes-sdk/platform/runtime/auth
 import { getOrCreateCompanionToken, buildCompanionConnectionInfo, encodeConnectionPayload, formatConnectionBlock } from '@pellux/goodvibes-sdk/platform/pairing/index';
 import { generateQrMatrix, renderQrToString } from '@pellux/goodvibes-sdk/platform/pairing/qr-generator';
 import type { GoodVibesCliParseResult } from './types.ts';
+import { formatProviderAuthRoute, summarizeProviderAuthRoutes } from './provider-auth-routes.ts';
 import { classifyProviderSetup } from './provider-classification.ts';
 import { resolveRuntimeEndpointBinding } from './endpoints.ts';
 import { applyRuntimeEndpointFlagOverrides } from './config-overrides.ts';
@@ -378,11 +379,23 @@ async function renderProviders(runtime: CliCommandRuntime): Promise<string> {
     const snapshots = await listProviderRuntimeSnapshots(services.providerRegistry);
     const current = services.providerRegistry.getCurrentModel();
     if (sub === 'current') {
-      const value = { provider: current.provider, model: current.registryKey };
+      const snapshot = snapshots.find((candidate) => candidate.providerId === current.provider);
+      const authRoutes = snapshot?.runtime.auth?.routes ?? [];
+      const value = {
+        provider: current.provider,
+        model: current.registryKey,
+        configured: snapshot?.runtime.auth?.configured ?? true,
+        configuredVia: snapshot?.runtime.auth?.mode ?? 'unknown',
+        authRoutes,
+        authRouteSummary: summarizeProviderAuthRoutes(authRoutes),
+      };
       return formatJsonOrText(runtime.cli)(value, [
         'GoodVibes current provider',
         `  provider: ${current.provider}`,
         `  model: ${current.registryKey}`,
+        `  configured: ${yesNo(value.configured)}`,
+        `  via: ${value.configuredVia}`,
+        `  auth routes: ${value.authRouteSummary}`,
       ].join('\n'));
     }
     if (sub === 'use' || sub === 'set') {
@@ -417,13 +430,21 @@ async function renderProviders(runtime: CliCommandRuntime): Promise<string> {
         configured: snapshot.runtime.auth?.configured ?? true,
         modelCount: snapshot.modelCount,
       });
-      return formatJsonOrText(runtime.cli)({ ...snapshot, setup }, [
+      const authRoutes = snapshot.runtime.auth?.routes ?? [];
+      return formatJsonOrText(runtime.cli)({
+        ...snapshot,
+        setup,
+        authRoutes,
+        authRouteSummary: summarizeProviderAuthRoutes(authRoutes),
+      }, [
         `Provider ${snapshot.providerId}`,
         `  active: ${yesNo(snapshot.active)}`,
         `  setup: ${setup.setupLabel}`,
         `  configured: ${yesNo(snapshot.runtime.auth?.configured ?? true)}`,
         `  via: ${snapshot.runtime.auth?.mode ?? 'unknown'}`,
         `  models: ${snapshot.modelCount}`,
+        `  auth routes: ${summarizeProviderAuthRoutes(authRoutes)}`,
+        ...authRoutes.map((route) => `    ${formatProviderAuthRoute(route)}`),
         `  detail: ${snapshot.runtime.auth?.detail ?? snapshot.runtime.notes?.join('; ') ?? ''}`,
       ].join('\n'));
     }
@@ -442,11 +463,13 @@ async function renderProviders(runtime: CliCommandRuntime): Promise<string> {
       models: snapshot.modelCount,
       current: current.provider === snapshot.providerId,
       detail: snapshot.runtime.auth?.detail ?? snapshot.runtime.notes?.join('; ') ?? '',
+      authRoutes: snapshot.runtime.auth?.routes ?? [],
+      authRouteSummary: summarizeProviderAuthRoutes(snapshot.runtime.auth?.routes),
     }));
     return formatJsonOrText(runtime.cli)(value, [
       'GoodVibes providers',
       ...value.map((provider) =>
-        `  ${provider.current ? '*' : ' '} ${provider.provider.padEnd(18)} setup=${provider.setupClass} configured=${yesNo(provider.configured)} via=${provider.configuredVia ?? 'n/a'} models=${provider.models} ${provider.detail ?? ''}`.trimEnd(),
+        `  ${provider.current ? '*' : ' '} ${provider.provider.padEnd(18)} setup=${provider.setupClass} configured=${yesNo(provider.configured)} via=${provider.configuredVia ?? 'n/a'} models=${provider.models} routes=${provider.authRouteSummary} ${provider.detail ?? ''}`.trimEnd(),
       ),
     ].join('\n'));
   });

package/src/cli/provider-auth-routes.ts

@@ -0,0 +1,22 @@
+import type { ProviderAuthRouteDescriptor } from '@pellux/goodvibes-sdk/platform/providers/interface';
+
+function routeUsable(route: ProviderAuthRouteDescriptor): boolean {
+  return route.usable ?? route.configured;
+}
+
+export function summarizeProviderAuthRoutes(routes: readonly ProviderAuthRouteDescriptor[] | undefined): string {
+  if (!routes?.length) return 'n/a';
+  const configured = routes.filter((route) => route.configured).length;
+  const usable = routes.filter(routeUsable).length;
+  return `${configured}/${routes.length} configured, ${usable}/${routes.length} usable`;
+}
+
+export function formatProviderAuthRoute(route: ProviderAuthRouteDescriptor): string {
+  const status = [
+    route.configured ? 'configured' : 'not configured',
+    routeUsable(route) ? 'usable' : 'not usable',
+    route.freshness,
+  ].filter((part): part is string => Boolean(part));
+  const detail = route.detail?.trim();
+  return `${route.label} [${route.route}; ${status.join(', ')}]${detail ? ` - ${detail}` : ''}`;
+}

package/src/input/command-registry.ts

@@ -19,6 +19,7 @@ import type { OpsApi } from '@pellux/goodvibes-sdk/platform/runtime/ops-api';
 import type { OperatorClient } from '@pellux/goodvibes-sdk/platform/runtime/operator-client';
 import type { PeerClient } from '@pellux/goodvibes-sdk/platform/runtime/peer-client';
 import type { DirectTransport } from '@pellux/goodvibes-sdk/platform/runtime/transports/direct';
+import type { VoiceProviderRegistry, VoiceService } from '@pellux/goodvibes-sdk/platform/voice/index';
 import type {
   CommandWorkspaceShellServices,
 } from '@pellux/goodvibes-sdk/platform/runtime/shell-command-workspace';
@@ -58,6 +59,8 @@ export interface CommandUiActions {
   print: (text: string) => void;
   exit: () => void;
   submitInput?: (text: string, content?: import('@pellux/goodvibes-sdk/platform/providers/interface').ContentPart[]) => void;
+  submitSpokenInput?: (text: string, content?: import('@pellux/goodvibes-sdk/platform/providers/interface').ContentPart[]) => void;
+  stopSpokenOutput?: () => void;
   executeCommand?: (name: string, args: string[]) => Promise<boolean>;
   cancelGeneration?: () => void;
   completeModelSelection?: (selection: {
@@ -146,6 +149,8 @@ export interface CommandWorkspaceServices
 export interface CommandPlatformConfigServices {
   readonly config: DeepReadonly<GoodVibesConfig>;
   readonly configManager: ConfigManager;
+  readonly voiceProviderRegistry?: VoiceProviderRegistry;
+  readonly voiceService?: VoiceService;
 }
 
 export interface CommandPlatformServices

package/src/input/commands/services-runtime.ts

@@ -41,6 +41,7 @@ export function registerServicesRuntimeCommands(registry: CommandRegistry): void
           `  webhookUrl: ${inspection.hasWebhookUrl ? 'present' : 'missing'}`,
           `  signingSecret: ${inspection.hasSigningSecret ? 'present' : 'missing'}`,
           `  publicKey: ${inspection.hasPublicKey ? 'present' : 'missing'}`,
+          `  appToken: ${inspection.hasAppToken ? 'present' : 'missing'}`,
         ].join('\n'));
         return;
       }