@drakulavich/kesha-voice-kit 1.30.0 → 2.0.0

package/src/mcp/tools.ts

@@ -1,9 +1,10 @@
 import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { errorMessage } from "../error-utils";
+import { installHint } from "../install-hint";
 import { z } from "zod";
 import { chmodSync, existsSync, readFileSync, statSync } from "fs";
 import { basename, isAbsolute, join } from "path";
-import { transcribe, transcribeWithTimestamps } from "../lib";
+import { assertAudioFileArgument, transcribeWithSegments } from "../transcribe";
 import { listVoices, aggregateLanguages } from "./voices";
 import { say, type SayFormat } from "../synth";
 import { DEFAULT_VOICE_ID, resolveSayVoice } from "../voice-routing";
@@ -66,8 +67,8 @@ export function registerTools(server: McpServer): void {
       const outPath = allocAudioPath(fmt);
       try {
         // An MCP caller has no stderr to read: the voice it is told is its only record (#942).
-        const resolvedVoice = (await resolveSayVoice(voice, undefined, text)) ?? DEFAULT_VOICE_ID;
-        await say({ text, voice: resolvedVoice, rate, format: fmt, out: outPath });
+        const resolvedVoice = (await resolveSayVoice(voice, undefined, text, { signal: extra.signal })) ?? DEFAULT_VOICE_ID;
+        await say({ text, voice: resolvedVoice, rate, format: fmt, out: outPath, signal: extra.signal });
         chmodSync(outPath, 0o600);
         const bytes = statSync(outPath).size;
         const file = basename(outPath);
@@ -128,17 +129,11 @@ export function registerTools(server: McpServer): void {
         return { isError: true, content: [{ type: "text" as const, text: `File not found: ${path}${hint}` }] };
       }
       try {
-        if (timestamps) {
-          const out = await transcribeWithTimestamps(path);
-          return {
-            content: [{ type: "text" as const, text: out.text }],
-            structuredContent: { text: out.text, segments: out.segments ?? [] },
-          };
-        }
-        const text = await transcribe(path);
+        assertAudioFileArgument(path);
+        const out = await transcribeWithSegments(path, { signal: extra.signal, timestamps });
         return {
-          content: [{ type: "text" as const, text: text }],
-          structuredContent: { text, segments: [] },
+          content: [{ type: "text" as const, text: out.text }],
+          structuredContent: { text: out.text, segments: timestamps ? out.segments : [] },
         };
       } catch (err) {
         return { isError: true, content: [{ type: "text" as const, text: errorMessage(err) }] };
@@ -169,8 +164,9 @@ export function registerTools(server: McpServer): void {
     async () => {
       try {
         const voices = await listVoices();
+        const text = voices.length === 0 ? `0 voices installed. Run: ${installHint("--tts")}` : `${voices.length} voices installed.`;
         return {
-          content: [{ type: "text" as const, text: `${voices.length} voices installed.` }],
+          content: [{ type: "text" as const, text }],
           structuredContent: { voices },
         };
       } catch (err) {

package/src/package-info.ts

@@ -1,6 +1,32 @@
 import pkg from "../package.json" with { type: "json" };
+import type { AssetPins } from "./engine-install";
+
+type PackageFields = { version?: unknown; kesha?: { engine?: unknown } };
+
+function isAssetPins(value: unknown): value is AssetPins {
+  const pins = value as { version?: unknown; sha256?: unknown; size?: unknown } | null;
+  return (
+    typeof pins?.version === "string" &&
+    typeof pins.sha256 === "object" &&
+    pins.sha256 !== null &&
+    Object.values(pins.sha256).every((hash) => typeof hash === "string" && /^[0-9a-f]{64}$/.test(hash)) &&
+    typeof pins.size === "object" &&
+    pins.size !== null &&
+    Object.values(pins.size).every((bytes) => Number.isSafeInteger(bytes) && (bytes as number) > 0)
+  );
+}
+
+/** The Engine this CLI installs: the pin `release.yml` injects at publish, else the CLI's own version. */
+export function resolveEngine(fields: PackageFields): { version: string; pins?: AssetPins } {
+  const injected = fields.kesha?.engine;
+  if (isAssetPins(injected)) return { version: injected.version, pins: injected };
+  return { version: typeof fields.version === "string" ? fields.version : "unknown" };
+}
+
+const engine = resolveEngine(pkg as PackageFields);
 
 export const packageName = typeof pkg.name === "string" ? pkg.name : "unknown";
 export const packageVersion = typeof pkg.version === "string" ? pkg.version : "unknown";
-export const engineVersion =
-  typeof pkg.keshaEngine?.version === "string" ? pkg.keshaEngine.version : packageVersion;
+export const engineVersion = engine.version;
+/** Undefined in a source checkout; the installer then verifies against each release's own SHA256SUMS. */
+export const injectedEnginePins = engine.pins;

package/src/paths.ts

@@ -1,8 +1,8 @@
-import { homedir } from "os";
 import { join } from "path";
+import { resolveStatePaths } from "./state-paths";
 
 export function keshaCacheDir(): string {
-  return process.env.KESHA_CACHE_DIR ?? join(homedir(), ".cache", "kesha");
+  return resolveStatePaths().cacheDir.path;
 }
 
 /** The `.exe` suffix is a platform fact, not a per-target one: an extensionless PE is not reliably spawnable. */

package/src/process-tree.ts

@@ -1,4 +1,7 @@
+import { KeshaError } from "./engine/events";
+
 type ManagedSignal = "SIGINT" | "SIGTERM" | "SIGKILL";
+type ReceivedSignal = "SIGINT" | "SIGTERM" | "SIGHUP";
 
 interface KillableProcess {
   pid: number;
@@ -16,13 +19,19 @@ const activeProcesses = new Set<ActiveProcess>();
 let signalHandlersInstalled = false;
 let pendingSignalCleanup:
   | {
+      signal: ReceivedSignal;
       exitCode: number;
       done: Promise<void>;
+      settle: () => void;
     }
   | null = null;
 
-export function engineAbortError(): Error {
-  const err = new Error("kesha-engine process aborted");
+/** The rejection for a cancelled run; `name` stays `AbortError` so signal-driven callers can keep matching on it. */
+export function engineAbortError(): KeshaError {
+  const err = new KeshaError("E_INTERRUPTED", "kesha-engine process aborted", {
+    exitCode: 130,
+    hint: "the caller's AbortSignal was aborted; the engine subprocess was terminated",
+  });
   err.name = "AbortError";
   return err;
 }
@@ -41,12 +50,34 @@ export function registerProcessTree(proc: KillableProcess): {
   return {
     dispose: () => {
       activeProcesses.delete(active);
+      if (activeProcesses.size === 0) pendingSignalCleanup?.settle();
     },
     terminate: (signal: ManagedSignal = "SIGTERM") => active.kill(signal),
     forceKillAfterGrace: () => scheduleForceKill(active),
   };
 }
 
+/** Terminates `tree` when `signal` fires and arms the force kill; `dispose` detaches the listener once the run is over. */
+export function abortOnSignal(
+  tree: { terminate: (signal?: ManagedSignal) => void; forceKillAfterGrace: () => Timer },
+  signal: AbortSignal | undefined,
+): { readonly aborted: boolean; dispose: () => void } {
+  let aborted = false;
+  let forceKillTimer: Timer | undefined;
+  const abort = () => {
+    aborted = true;
+    tree.terminate("SIGTERM");
+    forceKillTimer ??= tree.forceKillAfterGrace();
+  };
+  signal?.addEventListener("abort", abort, { once: true });
+  return {
+    get aborted() {
+      return aborted;
+    },
+    dispose: () => signal?.removeEventListener("abort", abort),
+  };
+}
+
 export function getPendingSignalExitCode(): number | null {
   return pendingSignalCleanup?.exitCode ?? null;
 }
@@ -57,6 +88,18 @@ export async function waitForPendingSignalCleanup(): Promise<number | null> {
   return pendingSignalCleanup.exitCode;
 }
 
+/** The `E_INTERRUPTED` failure every run refused after the CLI received a signal carries; null while none has arrived. */
+export function pendingInterruption(): KeshaError | null {
+  if (!pendingSignalCleanup) return null;
+  const { signal, exitCode } = pendingSignalCleanup;
+  return new KeshaError("E_INTERRUPTED", `interrupted (${signal})`, { exitCode });
+}
+
+/** The `E_INTERRUPTED` failure of a run the CLI's own signal cut short, named after that signal rather than whatever the engine died of; null while no signal has arrived, and null for a run that still exited 0, whose output is whole. */
+export function interruptedRun(exitCode: number): KeshaError | null {
+  return exitCode === 0 ? null : pendingInterruption();
+}
+
 export function terminateProcessTree(proc: KillableProcess, signal: ManagedSignal = "SIGTERM"): void {
   if (!Number.isFinite(proc.pid) || proc.pid <= 0) {
     safeKillDirect(proc, signal);
@@ -94,40 +137,49 @@ function safeKillDirect(proc: KillableProcess, signal: ManagedSignal): void {
   }
 }
 
-function scheduleForceKill(proc: ActiveProcess, opts: { ref?: boolean } = {}): Timer {
+function scheduleForceKill(proc: ActiveProcess): Timer {
   const timer = setTimeout(() => proc.kill("SIGKILL"), FORCE_KILL_GRACE_MS);
-  if (opts.ref !== true) timer.unref?.();
+  timer.unref?.();
   return timer;
 }
 
+/** The CLI's own signal: SIGKILL after the grace, then give up on a tree that outlives even that, so the exit stays bounded. */
+function scheduleSignalForceKill(proc: ActiveProcess): void {
+  setTimeout(() => {
+    proc.kill("SIGKILL");
+    setTimeout(() => pendingSignalCleanup?.settle(), FORCE_KILL_GRACE_MS);
+  }, FORCE_KILL_GRACE_MS);
+}
+
 function ensureSignalHandlers(): void {
   if (signalHandlersInstalled) return;
   signalHandlersInstalled = true;
-  process.on("SIGINT", () => terminateActiveProcessTrees("SIGINT", 130));
-  process.on("SIGTERM", () => terminateActiveProcessTrees("SIGTERM", 143));
+  process.on("SIGINT", () => terminateActiveProcessTrees("SIGINT", "SIGINT", 130));
+  process.on("SIGTERM", () => terminateActiveProcessTrees("SIGTERM", "SIGTERM", 143));
+  // The engine runs detached in its own group, so a terminal hangup only reaches it forwarded; Windows has no hangup to forward.
+  if (process.platform !== "win32") process.on("SIGHUP", () => terminateActiveProcessTrees("SIGHUP", "SIGTERM", 129));
 }
 
-function terminateActiveProcessTrees(signal: ManagedSignal, exitCode: number): void {
+function terminateActiveProcessTrees(signal: ReceivedSignal, forward: ManagedSignal, exitCode: number): void {
   const processes = [...activeProcesses];
-  process.exitCode = exitCode;
 
   for (const proc of processes) {
-    proc.kill(signal);
-    scheduleForceKill(proc, { ref: true });
+    proc.kill(forward);
+    scheduleSignalForceKill(proc);
   }
 
+  // The first signal names the run's outcome; a repeat only re-signals what is still running.
   if (pendingSignalCleanup) {
     return;
   }
+  process.exitCode = exitCode;
 
-  const delayMs = processes.length > 0
-    ? FORCE_KILL_GRACE_MS + SIGNAL_EXIT_BUFFER_MS
-    : SIGNAL_EXIT_BUFFER_MS;
-  let resolveDone!: () => void;
+  let settle!: () => void;
   const done = new Promise<void>((resolve) => {
-    resolveDone = resolve;
+    settle = resolve;
   });
-  pendingSignalCleanup = { exitCode, done };
-  setTimeout(resolveDone, delayMs);
-  done.then(() => process.exit(exitCode));
+  pendingSignalCleanup = { signal, exitCode, done, settle };
+  // Armed from the drain, not the signal: a fixed deadline raced the force kill under load and exited before the report (#1305).
+  void done.then(() => setTimeout(() => process.exit(exitCode), SIGNAL_EXIT_BUFFER_MS));
+  if (processes.length === 0) settle();
 }

package/src/semver.mjs

@@ -1,18 +1,15 @@
 /**
  * SemVer 2.0 — the one place in this repo that knows the grammar.
  *
- * `kesha install --engine-version`, the version drift gate, the alpha derivation, the npm
- * dist-tag resolver, the package.json writer and the Linux package names all decide "is this
- * a version" or "which is newer". Separate copies disagree at the edges: `derive-alpha-version`
- * asserts its output sorts above the pin that `check-versions` later validates, so one parser
- * accepting what another refuses is a release that passes derivation and fails the gate
- * (#685, #738).
+ * `kesha install --engine-version`, the version drift gate, the release plan, the
+ * package.json writer and the Linux package names all decide "is this a version" or "which
+ * is newer". Separate copies disagree at the edges: one parser accepting what another
+ * refuses is a release that passes planning and fails the gate (#685, #738).
  *
- * Stays `.mjs`: npm-publish.yml, release-npm-publish.yml and homebrew-tap.yml run their
- * scripts under node, which cannot import a `.ts` module. Types live in `semver.d.mts`.
+ * Stays `.mjs`: release.yml runs some of its callers under node, which cannot import a
+ * `.ts` module. Types live in `semver.d.mts`.
  *
- * The release *tag* grammar is deliberately not here — `.github/scripts/release-tags.mjs`
- * keeps it as a POSIX ERE string so bash `=~` and JavaScript consume identical text.
+ * The release *tag* grammar is deliberately not here: it lives in `.github/scripts/release-tags.mjs`.
  */
 
 /** The pattern published with the SemVer 2.0 spec; a looser one accepts `1.0.0-01` and `01.2.3`. */

package/src/shell-artifacts.ts

@@ -160,7 +160,7 @@ ${cases}
   fi
 }
 
-complete -F _kesha_completion kesha
+complete -o default -F _kesha_completion kesha
 `;
 }
 
@@ -203,6 +203,7 @@ ${commands}
       _arguments ${rootOptions}
     else
       _describe -t commands 'kesha command' commands
+      _files
     fi
     return
   fi
@@ -210,7 +211,8 @@ ${commands}
   case "$words[2]" in
 ${cases}
     *)
-      _arguments ${rootOptions}
+      _arguments ${rootOptions} \\
+      '*:audio file:_files'
       ;;
   esac
 }
@@ -233,7 +235,6 @@ function renderFishOption(bin: string, condition: string, option: CliOption): st
 function renderFish(model: ArtifactModel): string {
   const lines = ["# fish completion for kesha."];
 
-  lines.push("complete -c kesha -f");
   for (const command of model.commands) {
     lines.push(
       `complete -c kesha -n '__fish_use_subcommand' -a '${command.name}' -d '${fishEscape(command.description)}'`,

package/src/state-paths.ts

@@ -0,0 +1,84 @@
+import { homedir, tmpdir } from "os";
+import { posix, win32 } from "path";
+
+export type StatePathSource = "default" | "KESHA_HOME" | "KESHA_CACHE_DIR" | "KESHA_LOG_DIR" | "KESHA_STATS_DB";
+
+export interface StatePath {
+  path: string;
+  source: StatePathSource;
+}
+
+/** The four places Kesha writes, each with the rule that decided it (openspec `state-directories`). */
+export interface StatePaths {
+  cacheDir: StatePath;
+  logDir: StatePath;
+  statsDbPath: StatePath;
+  mcpAudioDir: StatePath;
+}
+
+type Env = Record<string, string | undefined>;
+
+// Anchored once: a core-API caller that chdir()s later must keep one root for the whole process.
+const STARTUP_CWD = process.cwd();
+
+function setting(env: Env, name: string): string | undefined {
+  const value = env[name];
+  return value === undefined || value === "" ? undefined : value;
+}
+
+/** Precedence per location: its own variable, then `KESHA_HOME`, then the platform default. */
+export function resolveStatePaths(
+  env: Env = process.env,
+  platform: string = process.platform,
+  homeDir: string = homedir(),
+  tmpDir: string = tmpdir(),
+  cwd: string = STARTUP_CWD,
+): StatePaths {
+  const p = platform === "win32" ? win32 : posix;
+  // Absolute values stay verbatim: on win32 `resolve` would prepend a drive to a drive-less `\tmp\x`.
+  const anchor = (value: string): string => (p.isAbsolute(value) ? value : p.resolve(cwd, value));
+  const home = setting(env, "KESHA_HOME");
+  const homeRoot = home === undefined ? undefined : anchor(home);
+
+  const pick = (specific: "KESHA_CACHE_DIR" | "KESHA_LOG_DIR" | "KESHA_STATS_DB" | null, under: string, fallback: string): StatePath => {
+    const own = specific === null ? undefined : setting(env, specific);
+    if (own !== undefined && specific !== null) return { path: anchor(own), source: specific };
+    if (homeRoot !== undefined) return { path: p.join(homeRoot, under), source: "KESHA_HOME" };
+    return { path: fallback, source: "default" };
+  };
+
+  const defaults = platformDefaults(p, platform, env, homeDir, tmpDir);
+  return {
+    cacheDir: pick("KESHA_CACHE_DIR", "cache", defaults.cache),
+    logDir: pick("KESHA_LOG_DIR", "logs", defaults.logs),
+    statsDbPath: pick("KESHA_STATS_DB", "stats.sqlite", defaults.stats),
+    mcpAudioDir: pick(null, "mcp-audio", defaults.mcp),
+  };
+}
+
+function platformDefaults(p: typeof posix | typeof win32, platform: string, env: Env, homeDir: string, tmpDir: string) {
+  const cache = p.join(homeDir, ".cache", "kesha");
+  const mcp = p.join(tmpDir, "kesha-mcp");
+  if (platform === "darwin") {
+    return {
+      cache,
+      mcp,
+      logs: p.join(homeDir, "Library", "Logs", "kesha"),
+      stats: p.join(homeDir, "Library", "Application Support", "kesha", "stats.sqlite"),
+    };
+  }
+  if (platform === "win32") {
+    return {
+      cache,
+      mcp,
+      logs: p.join(setting(env, "LOCALAPPDATA") ?? p.join(homeDir, "AppData", "Local"), "kesha", "logs"),
+      stats: p.join(setting(env, "APPDATA") ?? p.join(homeDir, "AppData", "Roaming"), "kesha", "stats.sqlite"),
+    };
+  }
+  return {
+    cache,
+    mcp,
+    logs: p.join(setting(env, "XDG_STATE_HOME") ?? p.join(homeDir, ".local", "state"), "kesha", "logs"),
+    stats: p.join(setting(env, "XDG_DATA_HOME") ?? p.join(homeDir, ".local", "share"), "kesha", "stats.sqlite"),
+  };
+}

package/src/stats.ts

@@ -6,6 +6,7 @@ import { homedir } from "os";
 import { dirname, extname, join } from "path";
 import { log } from "./log";
 import { packageVersion } from "./package-info";
+import { resolveStatePaths } from "./state-paths";
 
 const SCHEMA_VERSION = 1;
 const MAX_ERROR_MESSAGE_CHARS = 300;
@@ -577,16 +578,7 @@ export function renderErrors(rows: StatsErrorRow[]): string {
 }
 
 export function resolveStatsDbPath(): string {
-  if (process.env.KESHA_STATS_DB) return process.env.KESHA_STATS_DB;
-  if (process.platform === "darwin") {
-    return join(homedir(), "Library", "Application Support", "kesha", "stats.sqlite");
-  }
-  if (process.platform === "win32") {
-    const base = process.env.APPDATA || join(homedir(), "AppData", "Roaming");
-    return join(base, "kesha", "stats.sqlite");
-  }
-  const base = process.env.XDG_DATA_HOME || join(homedir(), ".local", "share");
-  return join(base, "kesha", "stats.sqlite");
+  return resolveStatePaths().statsDbPath.path;
 }
 
 export function artifactFromFile(

package/src/status.ts

@@ -1,6 +1,3 @@
-import { readdirSync, statSync } from "fs";
-import { join } from "path";
-import modelPlan from "../model-plan.json" with { type: "json" };
 import {
   isEngineInstalled,
   getEngineBinPath,
@@ -12,7 +9,7 @@ import {
   NOT_FUNCTIONAL_STATE,
   type EngineFunctionalHealth,
 } from "./engine-health";
-import { cacheComponentPaths, isInsideDir } from "./cache-layout";
+import { cacheComponents, cacheTotalBytes } from "./cache-layout";
 import { humanBytes } from "./format";
 import { installHint } from "./install-hint";
 import { log } from "./log";
@@ -24,9 +21,23 @@ import {
   fluidExternalTotalBytes,
   type FluidExternalRoot,
 } from "./fluid-roots";
-import { dirSizeBytes } from "./diagnostic-paths";
+import { resolveStatePaths, type StatePath } from "./state-paths";
+import { installedVoiceIds } from "./voice-inventory";
 import pc from "picocolors";
 
+/** Where this process writes, each with the rule that decided it (openspec `state-directories`). */
+export interface StatusPaths {
+  cache: StatePath;
+  logs: StatePath;
+  stats: StatePath;
+  mcpAudio: StatePath;
+}
+
+export function collectStatusPaths(): StatusPaths {
+  const p = resolveStatePaths();
+  return { cache: p.cacheDir, logs: p.logDir, stats: p.statsDbPath, mcpAudio: p.mcpAudioDir };
+}
+
 export function formatStatusLine(
   label: string,
   path: string | null,
@@ -78,6 +89,7 @@ export interface StatusReport {
   voices: string[];
   runtime: { bun: string; platform: string; arch: string };
   modelMirror: string | null;
+  paths: StatusPaths;
   hint: string | null;
   disk: StatusDiskUsage | null;
 }
@@ -91,9 +103,10 @@ export async function collectStatus(options: ShowStatusOptions = {}): Promise<St
   return {
     cliVersion: packageVersion,
     engine: { installed, path, capabilities },
-    voices: installed ? listInstalledVoices() : [],
+    voices: await installedVoiceIds(),
     runtime: { bun: Bun.version, platform: process.platform, arch: process.arch },
     modelMirror: activeModelMirror(),
+    paths: collectStatusPaths(),
     hint: engineHint(path, health),
     // Absent engine means no disk walk, matching the human path (#647).
     disk:
@@ -156,6 +169,9 @@ export function renderStatus(report: StatusReport): void {
   if (report.modelMirror) {
     log.info(formatStatusLine("Mirror", report.modelMirror, true));
   }
+  for (const [label, entry] of Object.entries(report.paths)) {
+    if (entry.source !== "default") log.info(formatStatusLine(pathLabel(label), `${entry.path} (${entry.source})`, true));
+  }
   log.info("");
 
   if (installed) {
@@ -169,6 +185,19 @@ export function renderStatus(report: StatusReport): void {
 }
 
 
+function pathLabel(key: string): string {
+  switch (key) {
+    case "cache":
+      return "Cache";
+    case "logs":
+      return "Logs";
+    case "stats":
+      return "Stats DB";
+    default:
+      return "MCP audio";
+  }
+}
+
 function logDiskRows(rows: StatusDiskComponent[], total: number, componentTotal: number): void {
   const labelWidth = Math.max(...rows.map((r) => r.label.length), "Total".length);
   for (const r of rows) {
@@ -201,19 +230,10 @@ function logExternalRoots(disk: StatusDiskUsage): void {
 
 function collectDiskUsage(binPath: string, backend?: string, homeDir?: string): StatusDiskUsage {
   const cache = keshaCacheDir();
-  // Two levels up from the binary (`<cache>/engine/bin/`) so future engine-root siblings are counted.
-  const engineDir = join(binPath, "..", "..");
-
-  const components: StatusDiskComponent[] = [];
-  for (const c of cacheComponentPaths(cache, engineDir, isCoremlBackend(backend))) {
-    const sizeBytes = dirSizeBytes(c.path);
-    if (sizeBytes > 0) components.push({ label: c.label, sizeBytes });
-  }
-
-  // Sum cache root + engine dir separately so `KESHA_ENGINE_BIN` overrides outside the cache are still counted.
-  const cacheTotal = dirSizeBytes(cache);
-  const engineOutsideCache = isInsideDir(engineDir, cache) ? 0 : dirSizeBytes(engineDir);
-  const totalBytes = cacheTotal + engineOutsideCache;
+  const components: StatusDiskComponent[] = cacheComponents(cache, binPath, isCoremlBackend(backend))
+    .filter((c) => c.sizeBytes > 0)
+    .map((c) => ({ label: c.label, sizeBytes: c.sizeBytes }));
+  const totalBytes = cacheTotalBytes(cache, binPath);
   const externalRoots = fluidExternalRoots({ homeDir, cacheRoot: cache });
   const externalTotalBytes = fluidExternalTotalBytes(externalRoots);
 
@@ -247,26 +267,3 @@ export function activeModelMirror(): string | null {
   const trimmed = raw.trim().replace(/\/+$/, "");
   return trimmed.length > 0 ? trimmed : null;
 }
-
-function listInstalledVoices(): string[] {
-  const cache = keshaCacheDir();
-  const voices: string[] = [];
-  try {
-    const kokoro = readdirSync(join(cache, "models", "kokoro-82m", "voices"));
-    for (const f of kokoro) {
-      if (f.endsWith(".bin")) voices.push(`en-${f.replace(/\.bin$/, "")}`);
-    }
-  } catch {
-    /* Kokoro not installed */
-  }
-  try {
-    // Joined to `models/manifest.rs::VOSK_RU_FILES` through the plan, so a sixth entry needs no edit here (#1132).
-    for (const { relPath } of modelPlan.voskRu) statSync(join(cache, relPath));
-    for (const id of ["f01", "f02", "f03", "m01", "m02"]) {
-      voices.push(`ru-vosk-${id}`);
-    }
-  } catch {
-    /* Vosk not installed */
-  }
-  return voices.sort();
-}