@drakulavich/kesha-voice-kit 1.28.0 → 1.30.0

package/NOTICES.md

@@ -19,7 +19,7 @@ see [speechbrain/lang-id-voxlingua107-ecapa](https://huggingface.co/speechbrain/
 ### Silero VAD v5 (opt-in: `kesha install --vad`)
 
 Voice activity detection. MIT. Authored by [Silero Team](https://github.com/snakers4/silero-vad).
-Pinned to the `v6.2.1` tag.
+Pinned to a commit (the `v6.2.1` tag's target at the time of pinning).
 
 ## Models downloaded by `kesha install --tts`
 

package/README.md

@@ -36,14 +36,14 @@ bun add -g @drakulavich/kesha-voice-kit
 kesha --version                                 # confirms `kesha` resolved on PATH
 
 # 3. Download the engine and models — pick one path
-kesha init                                      # guided: backend, languages, TTS voices
+kesha init                                      # guided: TTS languages and optional VAD / diarization
 kesha install --plan && kesha install           # manual: preview the sizes, then download
 
 # 4. Transcribe
 kesha audio.ogg                                 # transcript to stdout
 ```
 
-`kesha install` pulls ~2.5 GB on Linux/Windows and ~0.6 GB on Apple Silicon, whose CoreML engine reads a smaller model set. It is always explicit — nothing downloads behind your back — and the model step has no progress bar, so expect a few quiet minutes. If `bun --version` fails right after step 1, reload your PATH: `exec $SHELL -l`.
+`kesha install` pulls ~2.5 GB on Linux/Windows and ~0.6 GB on Apple Silicon, whose CoreML engine reads a smaller model set. It is always explicit — nothing downloads behind your back — and reports download progress on stderr. If `bun --version` fails right after step 1, reload your PATH: `exec $SHELL -l`.
 
 Prefer Homebrew or Docker? See [Other install methods](#other-install-methods).
 Air-gapped or behind a corporate mirror? See [docs/model-mirror.md](docs/model-mirror.md).
@@ -90,15 +90,16 @@ $ kesha freedom.ogg tahiti.ogg
 ```
 
 - **Record from the mic (macOS):** `kesha record --out hello.wav` writes microphone audio to a WAV file (`kesha hello.wav` transcribes it). macOS prompts for microphone access on first use — grant it under System Settings → Privacy & Security → Microphone if it was denied. On Linux/Windows or headless boxes, pass any existing audio file straight to `kesha` instead.
-- **Dictate straight to text (darwin-arm64):** `kesha record --live` transcribes the mic as it captures and prints the transcript to stdout — no WAV in between, so it pipes (`kesha record --live | pbcopy`). Progress goes to stderr. Other platforms keep the two-step `record --out` + transcribe flow. An interruption is recoverable: Ctrl-C (or SIGTERM) stops the session, still prints what you dictated, and exits 130/143, and the audio is spilled to a recovery WAV under `~/.cache/kesha/recordings/` — named on stderr when the session starts, deleted once the transcript has actually been delivered, kept if anything — a signal, a crash, a closed terminal, a dead pipe — got in the way first ([#962](https://github.com/drakulavich/kesha-voice-kit/issues/962)).
+- **Dictate straight to text (darwin-arm64):** `kesha record --live` transcribes the mic as it captures and prints the transcript to stdout — no WAV in between, so it pipes (`kesha record --live | pbcopy`). To end after trailing silence, explicitly install VAD then opt in: `kesha install --vad && kesha record --live --auto-stop`. The defaults are 1,000 ms of silence after 250 ms of speech; tune them with `--auto-stop-silence-ms`, `--auto-stop-min-speech-ms`, and `--auto-stop-threshold`. Progress goes to stderr. Linux and Windows do not capture the microphone; pass an existing audio file to `kesha` to transcribe it. An interruption is recoverable: Ctrl-C (or SIGTERM) stops the session, still prints what you dictated, and exits 130/143, and the audio is spilled to a recovery WAV under `~/.cache/kesha/recordings/` — named on stderr when the session starts, deleted once the transcript has actually been delivered, kept if anything — a signal, a crash, a closed terminal, a dead pipe — got in the way first ([#962](https://github.com/drakulavich/kesha-voice-kit/issues/962)).
 - **Long / silence-heavy audio:** install VAD (`kesha install --vad`); Kesha auto-uses it past 120 s. Without VAD, long audio falls back to fixed ASR chunks. See [docs/vad.md](docs/vad.md).
 - **Speaker diarization** (darwin-arm64): `kesha install --diarize` (which installs VAD too), then `kesha --json --speakers meeting.m4a` stamps each segment with a `speaker` id. `--speakers` engages VAD windowing itself at any duration, so it cannot be combined with `--no-vad`. Linux/Windows return a clear "darwin-arm64 only" error ([#199](https://github.com/drakulavich/kesha-voice-kit/issues/199)).
 - **Word-level timestamps** (every platform): `kesha --json --timestamps audio.ogg` adds a `words` array to each segment — `{ "word": "email", "start": 0.72, "end": 1.12 }` — on the same file-relative clock as the segment, so a word always lies inside the segment carrying it. Read them off the decoder's own frame grid, so: times are quantised to 0.08 s, consecutive spans may overlap (each `end` is a per-word duration prediction, not the next word's `start`), `end >= start` rather than strictly greater, and punctuation stays attached to its word. The key is simply absent where a segment has none — any segment `--itn` rewrote, for one — so check the `transcribe.words` capability rather than expecting an empty array ([#720](https://github.com/drakulavich/kesha-voice-kit/issues/720)).
+- **Text-language detection:** JSON and TOON results include `textLanguage` with a language code, confidence, and its `source`. On macOS Kesha uses Apple `NLLanguageRecognizer`; elsewhere it uses the bundled `tinyld` fallback, whose confidence scale is different. This is separate from `audioLanguage`, which identifies the spoken audio when available.
 - **Written-form numbers:** `--itn` rewrites what the model spells out — `"two hundred thirty two"` → `"232"`, `"five dollars and fifty cents"` → `"$5.50"`. Opt-in, every platform, timestamps untouched. English-only in practice; Russian and the rest pass through unchanged. Spoken punctuation names stay words (`"dot"`, `"comma"`, `"the period of growth"`) because Kesha transcribes speech rather than dictation — so `"example dot com"` keeps its words too ([#822](https://github.com/drakulavich/kesha-voice-kit/issues/822)). A sentence `"and"` survives the number that follows it (`"cats and three dogs"` → `"cats and 3 dogs"`), while an `"and"` the number owns still joins it (`"three hundred and five"` → `"305"`) ([#1000](https://github.com/drakulavich/kesha-voice-kit/issues/1000)) — and no longer splits the number around it (`"two hundred and thirty two"` → `"232"`, not `"230 2"`) ([#1006](https://github.com/drakulavich/kesha-voice-kit/issues/1006)). A hyphenated number reads the same as the spaced form (`"twenty-five apples"` → `"25 apples"`), while a hyphen between ordinary words is left alone (`"well-known"`, `"state-of-the-art"`, `"twenty-something"`) ([#1004](https://github.com/drakulavich/kesha-voice-kit/issues/1004)).
 
 ## Text-to-speech
 
-Kesha speaks back in [9 languages](docs/languages.md#text-to-speech). On macOS it picks the voice from the text's own language; on Linux and Windows text detection needs Apple frameworks, so state the language with `--lang <code>` (or the voice with `--voice <id>`) — otherwise the engine default speaks.
+Kesha speaks back in [9 languages](docs/languages.md#text-to-speech). Kokoro runs natively through FluidAudio CoreML/ANE on Apple Silicon and through ONNX on Linux and Windows; Russian uses Vosk-TTS, while `macos-*` system voices need no model download. On macOS Kesha picks the voice from the text's own language; on Linux and Windows, state the language with `--lang <code>` (or the voice with `--voice <id>`) — otherwise the engine default speaks.
 
 ```bash
 kesha install --tts                              # English voices; sizes differ per platform — preview: kesha install --plan

package/docs/product-positioning.md

@@ -21,7 +21,7 @@ The product promise is not "one model for every audio problem." The promise is a
 | Transcribe to structured output for scripts or agents | Stable | `kesha --json audio.ogg`, `kesha --toon audio.ogg`, `kesha --format transcript audio.ogg` |
 | Detect likely audio/text language during transcription | Stable | `--lang`, `--verbose`, JSON/TOON language fields |
 | Skip silence in long audio | Beta | `kesha --vad meeting.m4a`, auto-on for long audio when VAD is installed |
-| Synthesize English or Russian speech locally | Beta | `kesha say "text"`, `kesha install --tts` |
+| Synthesize supported languages locally | Beta | `kesha say "text"`, `kesha install --tts` |
 | Use macOS system voices without model downloads | Stable on macOS | `kesha say --voice macos-*` |
 | Label speakers in meeting transcripts | Preview, darwin-arm64 only | `kesha --json --vad --speakers meeting.m4a` |
 | Integrate with OpenClaw as a local voice model | Stable integration surface, user-configured route | `docs/openclaw.md` |
@@ -35,7 +35,7 @@ The product promise is not "one model for every audio problem." The promise is a
 - Streaming phone-call transcription or real-time conversation infrastructure.
 - Speaker identity across files. Diarization emits per-file cluster IDs, not names or persistent voice profiles.
 - Full SSML coverage. Kesha supports a practical subset for current TTS engines; unsupported tags should fail or warn clearly.
-- Universal TTS across all 25 STT languages. TTS is intentionally scoped to English, Russian, and macOS system voices.
+- Universal TTS across all 25 STT languages. TTS is intentionally scoped to its documented nine-language set and macOS system voices.
 - Model training, fine-tuning, or benchmark leadership on every dataset.
 - Browser/mobile SDKs. The supported product surface is CLI-first, with thin integrations around it.
 
@@ -47,7 +47,7 @@ The product promise is not "one model for every audio problem." The promise is a
 | JSON / TOON / transcript output formats | Stable | Intended for scripts, agents, and downstream tooling. |
 | Audio language detection | Stable | Used for warnings and structured metadata. |
 | VAD preprocessing | Beta | Useful for long or silence-heavy audio; short voice messages stay on the fast path. |
-| English/Russian TTS | Beta | Requires `kesha install --tts`; model cache and first-run cost are expected. |
+| Kokoro and Vosk TTS | Beta | Nine documented languages; requires `kesha install --tts`, so model cache and first-run cost are expected. |
 | macOS AVSpeech voices | Stable on macOS | Zero-install system voices; quality is OS voice quality, not neural TTS. |
 | SSML subset | Preview | `<prosody rate>`, Russian stress markers, and IPA support are engine-specific. |
 | Speaker diarization | Preview | darwin-arm64 only; cluster IDs are stable within one file only. |
@@ -63,8 +63,9 @@ The product promise is not "one model for every audio problem." The promise is a
 | STT | Supported, CoreML path | Not shipped | Supported, ONNX CPU path | Supported, ONNX CPU path | `aarch64-darwin`, `x86_64-linux` |
 | Audio language detection | Supported | Not shipped | Supported | Supported | Supported where the flake builds |
 | VAD | Supported with `kesha install --vad` | Not shipped | Supported with `kesha install --vad` | Supported with `kesha install --vad` | Supported where the engine path includes VAD assets |
-| TTS: English Kokoro | Supported, FluidAudio/CoreML in release builds | Not shipped | Supported, ONNX path | Supported, ONNX path | Supported except where noted in `docs/nix-install.md` |
+| TTS: Kokoro (`en` `es` `fr` `it` `pt`) | Supported, FluidAudio/CoreML in release builds | Not shipped | Supported, ONNX path | Supported, ONNX path | Supported except where noted in `docs/nix-install.md` |
 | TTS: Russian Vosk-TTS | Supported | Not shipped | Supported | Supported | Supported except where noted in `docs/nix-install.md` |
+| TTS: Kokoro (`hi` `ja` `zh`) | Supported, darwin-arm64 only | Not shipped | Not supported | Not supported | `aarch64-darwin` only |
 | macOS system voices | Supported | Not shipped | Not applicable | Not applicable | Supported on `aarch64-darwin` |
 | Speaker diarization | Preview, darwin-arm64 only | Not supported | Not supported | Not supported | Not wired into the Nix build yet |
 | Raycast extension | Supported | Not shipped | Not applicable | Not applicable | Not applicable |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@drakulavich/kesha-voice-kit",
-  "version": "1.28.0",
+  "version": "1.30.0",
   "description": "Give your tools a voice — speech to text and back, 25 languages, up to ~19× faster than Whisper. On your machine.",
   "type": "module",
   "bin": {
@@ -40,11 +40,10 @@
     }
   },
   "keshaEngine": {
-    "version": "1.24.10"
+    "version": "1.25.0"
   },
   "scripts": {
     "test": "bun test --timeout 30000",
-    "conveyor": "bun scripts/backlog.ts",
     "test:watch": "bun test --timeout 30000 --watch",
     "test:unit": "bun test --timeout 30000 tests/unit/",
     "test:cli-fast": "bun test --timeout 30000 tests/unit/ tests/integration/cli-contracts.test.ts tests/integration/error-codes-cli.test.ts tests/integration/say.test.ts",
@@ -110,6 +109,7 @@
   "overrides": {
     "hono": "^4.12.25",
     "fast-uri": "^3.1.5",
-    "ip-address": "^10.3.1"
+    "ip-address": "^10.3.1",
+    "smol-toml": "1.7.2"
   }
 }

package/src/cli/command-session.ts

@@ -4,6 +4,7 @@ import type {
   DiagnosticLogSession,
   DiagnosticSessionStatus,
 } from "../diagnostic-log";
+import { setEngineDebugSink } from "../engine/events";
 import { errorMessage } from "../error-utils";
 import { log } from "../log";
 import { createStatsRecorder } from "../stats";
@@ -46,12 +47,22 @@ export async function runCommandSession(
   };
   session.diagnosticLog.event("command.start", { command, ...startFields });
 
+  setEngineDebugSink((event) =>
+    session.diagnosticLog.event("engine.debug", {
+      t_ms: event.t_ms,
+      event: event.event ?? null,
+      message: event.message,
+      fields: event.fields === undefined ? null : JSON.stringify(event.fields),
+    }),
+  );
   let outcome: CommandOutcome;
   try {
     outcome = await body(session);
   } catch (err) {
     closeSessionQuietly(session, command, { status: "failed", itemCount: 0 });
     throw err;
+  } finally {
+    setEngineDebugSink(null);
   }
 
   // A flush error must not displace a failure the command already has to report (Greptile P1/P2 on #607).

package/src/cli/init.ts

@@ -2,13 +2,15 @@ import { defineCommand } from "citty";
 import { confirm, multiselect, isCancel, cancel } from "@clack/prompts";
 import { installCommandTokens, renderInstallPlan } from "../install-plan";
 import { log } from "../log";
+import { errorMessage } from "../error-utils";
+import { exitCodeFor } from "../engine/events";
 import { getEngineCapabilities } from "../engine";
 import {
   installableTtsLangs,
   performInstall,
   resolveBackendFlag,
   resolveNoCacheFlag,
-  unavailableBackendError,
+  unavailableBackendRefusal,
 } from "./install";
 import type { SharedInstallArgs } from "./types";
 
@@ -176,10 +178,10 @@ export async function promptInitSelection(
 
 /** Mirrors the guard in `performInstall`: a preview must not describe an install this platform rejects (#684). */
 async function printPlan(selection: InitSelection): Promise<boolean> {
-  const backendError = unavailableBackendError(selection.backend);
+  const backendError = unavailableBackendRefusal(selection.backend);
   if (backendError) {
-    log.error(backendError);
-    process.exitCode = 2;
+    log.error(errorMessage(backendError));
+    process.exitCode = exitCodeFor(backendError);
     return false;
   }
   log.info(

package/src/cli/install.ts

@@ -1,8 +1,9 @@
 import { defineCommand } from "citty";
 import { errorMessage } from "../error-utils";
-import { installEngine } from "../engine-install";
+import { assertPlatformCanInstall, installEngine } from "../engine-install";
 import { engineTarget, isDarwinArm64 } from "../engine-targets";
 import { getEngineBinPath, getEngineCapabilities, type EngineCapabilities } from "../engine";
+import { exitCodeFor, KeshaError } from "../engine/events";
 import { renderInstallPlan } from "../install-plan";
 import { maybeAskForStar } from "../star";
 import { log } from "../log";
@@ -171,6 +172,12 @@ function finishInstallDiagnostic(
   }
 }
 
+/** The refusal `install`, `install --plan` and `init --plan` all render the same way (#684). */
+export function unavailableBackendRefusal(backend: string | undefined): KeshaError | null {
+  const message = unavailableBackendError(backend);
+  return message ? new KeshaError("E_INVALID_ARG", message) : null;
+}
+
 /** Null when the requested backend is installable here. `KESHA_ENGINE_BIN` opts out — the user supplied their own engine. */
 export function unavailableBackendError(backend: string | undefined): string | null {
   const platformBackend = defaultBackendForPlatform();
@@ -197,11 +204,11 @@ export async function performInstall(options: PerformInstallOptions) {
   const { noCache, backend, ttsLangs, vad = false, diarize = false, plan = false, engineVersion } =
     options;
   // A plan for an unavailable backend previews what its own printed command rejects (#684).
-  const backendError = unavailableBackendError(backend);
+  const backendError = unavailableBackendRefusal(backend);
   if (plan) {
     if (backendError) {
-      log.error(backendError);
-      process.exitCode = 2;
+      log.error(errorMessage(backendError));
+      process.exitCode = exitCodeFor(backendError);
       return;
     }
     log.info(
@@ -225,16 +232,15 @@ export async function performInstall(options: PerformInstallOptions) {
       engineVersionOverride: engineVersion !== undefined,
     });
 
-    if (diarize && !(process.platform === "darwin" && process.arch === "arm64")) {
+    try {
+      assertPlatformCanInstall({ diarize });
+    } catch (err) {
       errorKind = "validation_failed";
-      throw new Error(
-        "--diarize is currently darwin-arm64 only " +
-        "(see https://github.com/drakulavich/kesha-voice-kit/issues/199).",
-      );
+      throw err;
     }
     if (backendError) {
       errorKind = "validation_failed";
-      throw new Error(backendError);
+      throw backendError;
     }
     await installEngine({ noCache, backend, ttsLangs, vad, diarize, version: engineVersion });
     await maybeAskForStar(getEngineBinPath(), packageVersion, log);
@@ -248,7 +254,7 @@ export async function performInstall(options: PerformInstallOptions) {
     const message = errorMessage(err);
     finishInstallDiagnostic(diagnosticLog, startedAt, "failed", errorKind);
     log.error(message);
-    process.exit(1);
+    process.exit(err instanceof KeshaError ? exitCodeFor(err) : 1);
   }
 }
 

package/src/cli/main.ts

@@ -2,7 +2,7 @@ import { defineCommand } from "citty";
 import { errorMessage } from "../error-utils";
 import { existsSync, statSync } from "fs";
 import { detectAll } from "tinyld";
-import { preflightTranscribeWithSegments, transcribeWithSegments } from "../transcribe";
+import { transcribeWithSegments, validateTranscribeRequest } from "../transcribe";
 import { detectAudioLanguageEngine, detectTextLanguageEngine } from "../engine";
 import type { LangDetectResult } from "../engine";
 import { log } from "../log";
@@ -23,7 +23,7 @@ import { diagnosticSizeBucket } from "../diagnostic-events";
 import { runCommandSession, type CommandSession } from "./command-session";
 import { USAGE_MESSAGE } from "./dispatch";
 import type { CliContext } from "./context";
-import { ENGINE_CODES, extractEngineErrorCode, TS_NATIVE_CODES } from "../error-codes";
+import { KeshaError } from "../engine/events";
 
 interface MainCommandArgs {
   _: string[];
@@ -301,26 +301,25 @@ async function processFile(
   const { stats, diagnosticLog } = recorders;
 
   if (!existsSync(file)) {
-    stats.recordError("input", new Error("File not found"), TS_NATIVE_CODES.INPUT_NOT_FOUND);
+    const err = new KeshaError("E_INPUT_NOT_FOUND", "File not found");
+    stats.recordError("input", err, err.code);
     diagnosticLog.event("input.missing", {
       command: "transcribe",
-      error_code: TS_NATIVE_CODES.INPUT_NOT_FOUND,
+      error_code: err.code,
     });
-    log.error(`${file}: error [${TS_NATIVE_CODES.INPUT_NOT_FOUND}]: File not found`);
-    return { ok: false, error: { file, code: TS_NATIVE_CODES.INPUT_NOT_FOUND, message: "File not found" } };
+    log.error(`${file}: ${errorMessage(err)}`);
+    return { ok: false, error: { file, code: err.code, message: err.message } };
   }
 
   if (isDirectoryPath(file)) {
-    stats.recordError("input", new Error("is a directory"), TS_NATIVE_CODES.INVALID_ARG);
+    const err = new KeshaError("E_INVALID_ARG", "is a directory (expected an audio file)");
+    stats.recordError("input", err, err.code);
     diagnosticLog.event("input.invalid", {
       command: "transcribe",
-      error_code: TS_NATIVE_CODES.INVALID_ARG,
+      error_code: err.code,
     });
-    log.error(`${file}: error [${TS_NATIVE_CODES.INVALID_ARG}]: is a directory (expected an audio file)`);
-    return {
-      ok: false,
-      error: { file, code: TS_NATIVE_CODES.INVALID_ARG, message: "is a directory (expected an audio file)" },
-    };
+    log.error(`${file}: ${errorMessage(err)}`);
+    return { ok: false, error: { file, code: err.code, message: err.message } };
   }
 
   const inputArtifact = artifactFromFile(file, "input_audio");
@@ -343,7 +342,7 @@ async function processFile(
     else write();
   };
   try {
-    await preflightTranscribeWithSegments({ vad: vadMode, timestamps, speakers, itn });
+    await validateTranscribeRequest({ vad: vadMode, timestamps, speakers, itn });
     progress = reportProgress
       ? createPercentProgress(`Transcribing ${file}`, {
           estimatedTotalMs: speakers ? 60 * 60 * 1000 : 30 * 60 * 1000,
@@ -394,8 +393,8 @@ async function processFile(
     return { ok: true, result };
   } catch (err: unknown) {
     progress?.stop();
+    const code = err instanceof KeshaError ? err.code : "E_TRANSCRIBE_FAILED";
     const stderrText = errorMessage(err);
-    const code = extractEngineErrorCode(stderrText) ?? ENGINE_CODES.TRANSCRIBE_FAILED;
     stats.recordError("transcribe", err, code);
     diagnosticLog.event("engine.exit", {
       command: "transcribe",

package/src/cli/record.ts

@@ -1,14 +1,16 @@
 import { defineCommand } from "citty";
 import { errorMessage } from "../error-utils";
+import { exitCodeFor, KeshaError } from "../engine/events";
 import {
   isEngineInstalled,
-  preflightRecordLive,
   recordEngine,
+  validateRecordRequest,
   type LiveAutoStopOptions,
   type RecordTarget,
 } from "../engine";
 import { installHint } from "../install-hint";
 import { log } from "../log";
+import { getPendingSignalExitCode, waitForPendingSignalCleanup } from "../process-tree";
 
 export interface RecordArgs {
   out?: string;
@@ -203,11 +205,16 @@ export const recordCommand = defineCommand({
       process.exit(1);
     }
     try {
-      if (resolved.target.live) await preflightRecordLive(resolved.target.autoStop !== undefined);
+      await validateRecordRequest(resolved.target, resolved.maxSeconds);
       await recordEngine(resolved.target, resolved.maxSeconds);
     } catch (err) {
+      const signalExitCode = getPendingSignalExitCode();
+      if (signalExitCode !== null) {
+        await waitForPendingSignalCleanup();
+        process.exit(signalExitCode);
+      }
       log.error(errorMessage(err));
-      process.exit(1);
+      process.exit(err instanceof KeshaError ? exitCodeFor(err) : 1);
     }
   },
 });

package/src/cli/say.ts

@@ -1,17 +1,10 @@
 import { defineCommand } from "citty";
 import { errorMessage } from "../error-utils";
-import {
-  getEngineBinPath,
-  isEngineInstalled,
-  spawnEngineProcess,
-  spawnStdioWithDebugFd,
-} from "../engine";
-import { installHint } from "../install-hint";
-import { registerProcessTree } from "../process-tree";
+import { exitCodeFor, KeshaError } from "../engine/events";
 import { log } from "../log";
 import {
+  listVoiceIds,
   say,
-  SayError,
   SUPPORTED_SAMPLE_RATES,
   type SayFormat,
   type SayOptions,
@@ -216,16 +209,16 @@ async function synthesizeAndEmit(
       },
     };
   } catch (err) {
-    const code = err instanceof SayError ? err.code : "E_INTERNAL";
-    const exitCode = err instanceof SayError ? err.exitCode : 4;
+    const code = err instanceof KeshaError ? err.code : "E_INTERNAL";
+    const exitCode = exitCodeFor(err);
     stats.recordError("tts", err, code);
-    log.error(err instanceof SayError ? err.stderr.trim() || err.message : errorMessage(err));
+    log.error(errorMessage(err));
     return {
       status: "failed",
       itemCount: 1,
       exitCode,
       finishFields: {
-        errorKind: err instanceof SayError ? "say_error" : "error",
+        errorKind: err instanceof KeshaError ? "say_error" : "error",
         exitCode,
         error_code: code,
       },
@@ -290,26 +283,15 @@ export const sayCommand = defineCommand({
   async run({ args }) {
     if (args.debug) log.debugEnabled = true;
     if (args["list-voices"]) {
-      if (!isEngineInstalled()) {
-        log.error(`kesha-engine not installed. run: ${installHint()}`);
-        process.exit(1);
-      }
-      // The engine prints the list directly — just relay its stdout + exit code.
-      const proc = spawnEngineProcess(
-        getEngineBinPath(),
-        ["say", "--list-voices"],
-        spawnStdioWithDebugFd(["inherit", "inherit", "inherit"]),
-      );
-      // Register so a Ctrl-C during a cold Engine load terminates it and exits 130/143 (#939);
-      // dispose before the process.exit below so the registration never outlives the run.
-      const tree = registerProcessTree(proc);
-      let exitCode: number;
+      let ids: string[];
       try {
-        exitCode = await proc.exited;
-      } finally {
-        tree.dispose();
+        ids = await listVoiceIds({ onProgress: (line) => log.status(line) });
+      } catch (err) {
+        log.error(errorMessage(err));
+        process.exit(exitCodeFor(err));
       }
-      process.exit(exitCode);
+      await Bun.write(Bun.stdout, ids.map((id) => `${id}\n`).join(""));
+      process.exit(0);
     }
 
     const flags = resolveSayFlags(args);

package/src/doctor.ts

@@ -34,7 +34,6 @@ const KNOWN_ENV_KEYS = [
   "KESHA_MODEL_MIRROR",
   "KESHA_STATS_DB",
   "KESHA_DEBUG",
-  "KESHA_DEBUG_FD",
   "KESHA_KOKORO_COMPUTE_UNITS",
   "KESHA_DIARIZE_COMPUTE_UNITS",
   "KESHA_DIARIZE_TIMEOUT_SECS",
@@ -221,6 +220,8 @@ async function collectEngine(redact: boolean): Promise<DoctorReport["engine"]> {
     probeError = `binary is present but does not run (${health.detail}); re-run \`kesha install\``;
   } else if (health.status === "mute") {
     probeError = `${health.detail}; re-run \`kesha install\``;
+  } else if (health.status === "protocol") {
+    probeError = health.detail;
   } else if (health.status === "ok") {
     capabilities = health.capabilities;
   }