@drakulavich/kesha-voice-kit 1.25.0 → 1.27.0-alpha.1

package/README.md

@@ -24,7 +24,7 @@
 
 ## Quick Start
 
-Runtime: **[Bun](https://bun.sh)** >= 1.3.0 · Platforms: macOS arm64, Linux x64. Windows x64 is currently blocked at install ([#216](https://github.com/drakulavich/kesha-voice-kit/issues/216)).
+Runtime: **[Bun](https://bun.sh)** >= 1.3.0 · Platforms: macOS arm64, Linux x64, Windows x64. Linux and Windows run the ONNX engine — everything except microphone capture (`kesha record`), macOS system voices, speaker diarization, and text language detection, which need Apple frameworks.
 
 ```bash
 # 1. Install Bun (skip if you have it) — Linux & macOS:
@@ -36,7 +36,8 @@ curl -fsSL https://bun.sh/install | bash        # or: brew install oven-sh/bun/b
 bun add -g @drakulavich/kesha-voice-kit
 kesha --version                                 # confirms `kesha` resolved on PATH
 kesha install --plan                            # preview exact download/disk sizes first — downloads nothing
-kesha install        # ~2.5 GB (engine + speech-to-text models), explicit — never automatic.
+kesha install        # ~2.5 GB on Linux/Windows; ~0.6 GB on Apple Silicon, whose CoreML
+                      # engine uses a different, smaller model set. Explicit — never automatic.
                       # No progress bar during the model step; can take several minutes.
                       # Prefer a guided wizard? `kesha init` walks through the same choices interactively.
 

package/completions/kesha.bash

@@ -21,7 +21,7 @@ _kesha_completion() {
     completions) opts="--help -h" ;;
     doctor) opts="--help -h --json --redact" ;;
     init) opts="--help -h --coreml --onnx --no-cache --plan --yes --tts --vad --diarize" ;;
-    install) opts="--help -h --coreml --onnx --no-cache --plan --tts --vad --diarize" ;;
+    install) opts="--help -h --coreml --onnx --no-cache --plan --tts --vad --diarize --engine-version" ;;
     logs) opts="--help -h --json" ;;
     manpage) opts="--help -h" ;;
     mcp) opts="--help -h" ;;

package/completions/kesha.fish

@@ -54,6 +54,7 @@ complete -c kesha -n '__fish_seen_subcommand_from install' -l plan -d 'Show down
 complete -c kesha -n '__fish_seen_subcommand_from install' -l tts -d 'Also install TTS models (English only; add codes for more, e.g. --tts en ru (preview sizes: kesha install --plan))'
 complete -c kesha -n '__fish_seen_subcommand_from install' -l vad -d 'Also install Silero VAD (~2.3MB) for long-audio preprocessing'
 complete -c kesha -n '__fish_seen_subcommand_from install' -l diarize -d 'Also install the Sortformer streaming-diarization model (~245MB, darwin-arm64 only — #199)'
+complete -c kesha -n '__fish_seen_subcommand_from install' -l engine-version -r -d 'Install this exact engine release instead of the pinned one (expert; the next install returns to the pin)'
 complete -c kesha -n '__fish_seen_subcommand_from logs' -l help -d 'Show help'
 complete -c kesha -n '__fish_seen_subcommand_from logs' -s h -d 'Show help'
 complete -c kesha -n '__fish_seen_subcommand_from logs' -l json -d 'Output status as JSON'

package/completions/kesha.zsh

@@ -75,7 +75,8 @@ _kesha() {
         '--plan[Show download, disk, and warm-up plan without changing local state]' \
         '--tts[Also install TTS models (English only; add codes for more, e.g. --tts en ru (preview sizes: kesha install --plan))]' \
         '--vad[Also install Silero VAD (~2.3MB) for long-audio preprocessing]' \
-        '--diarize[Also install the Sortformer streaming-diarization model (~245MB, darwin-arm64 only — #199)]'
+        '--diarize[Also install the Sortformer streaming-diarization model (~245MB, darwin-arm64 only — #199)]' \
+        '--engine-version=[Install this exact engine release instead of the pinned one (expert; the next install returns to the pin)]:engine version:'
       ;;
     logs)
       _arguments '--help[Show help]' \

package/docs/product-positioning.md

@@ -60,27 +60,29 @@ The product promise is not "one model for every audio problem." The promise is a
 
 | Capability | macOS arm64 | macOS x64 | Linux x64 | Windows x64 | Nix path |
 |---|---|---|---|---|---|
-| STT | Supported, CoreML path | Not shipped | Supported, ONNX CPU path | Blocked at install (#216) | `aarch64-darwin`, `x86_64-linux` |
-| Audio language detection | Supported | Not shipped | Supported | Blocked at install (#216) | Supported where the flake builds |
-| VAD | Supported with `kesha install --vad` | Not shipped | Supported with `kesha install --vad` | Blocked at install (#216) | Supported where the engine path includes VAD assets |
-| TTS: English Kokoro | Supported, FluidAudio/CoreML in release builds | Not shipped | Supported, ONNX path | Blocked at install (#216) | Supported except where noted in `docs/nix-install.md` |
-| TTS: Russian Vosk-TTS | Supported | Not shipped | Supported | Blocked at install (#216) | Supported except where noted in `docs/nix-install.md` |
+| 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: Russian Vosk-TTS | Supported | Not shipped | Supported | Supported | Supported except where noted in `docs/nix-install.md` |
 | 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 |
-| OpenClaw integration | Supported through CLI route | Not shipped | Supported through CLI route | Blocked at install (#216) | Use the installed `kesha` command from the chosen path |
-| Hermes Agent integration | Supported through command providers | Not shipped | Supported through command providers | Blocked at install (#216) | Use the installed `kesha` command from the chosen path |
+| OpenClaw integration | Supported through CLI route | Not shipped | Supported through CLI route | Supported through CLI route | Use the installed `kesha` command from the chosen path |
+| Hermes Agent integration | Supported through command providers | Not shipped | Supported through command providers | Supported through command providers | Use the installed `kesha` command from the chosen path |
 
 `macOS x64` means Intel Macs. Kesha does not currently publish a `darwin-x64` engine binary, so Intel Macs are intentionally marked as not shipped rather than implied to use the ONNX fallback.
 
-`Windows x64` shows "Blocked at install" because the CLI's install step
-refuses to run on Windows, not because no binary exists — `build-engine.yml`
-builds and publishes `kesha-engine-windows-x64.exe` with every release. The
-Vosk-TTS native dependency trips MSVC at link time, so the CLI blocks the
-install client-side rather than shipping a broken engine. See
-[issue #216](https://github.com/drakulavich/kesha-voice-kit/issues/216) for
-the underlying failure and the v1.4.x workaround; the toolkit is unusable on
-Windows until that lands.
+`Windows x64` runs the same ONNX engine as Linux. The MSVC link failure behind
+[issue #216](https://github.com/drakulavich/kesha-voice-kit/issues/216) was fixed by
+vendoring the Vosk-TTS runtime under `rust/vendor/vosk-tts/`, and the CLI's install
+refusal — which outlived that fix by about twenty minor versions — is gone. CI now runs
+a cold `kesha install` on `windows-latest`, synthesises with both the Kokoro and Vosk
+engines, and transcribes the result back, so the platform's row reflects a tested path
+rather than a published binary nobody had run.
+
+Microphone capture is the one Linux/Windows gap that is not about Apple frameworks:
+`kesha record` is macOS-only, so pass an existing audio file instead.
 
 ## When to choose something else
 

package/man/kesha.1

@@ -141,6 +141,9 @@ Also install Silero VAD (~2.3MB) for long\-audio preprocessing
 .TP
 .B \-\-diarize
 Also install the Sortformer streaming\-diarization model (~245MB, darwin\-arm64 only — #199)
+.TP
+.B \-\-engine\-version
+Install this exact engine release instead of the pinned one (expert; the next install returns to the pin)
 .SS logs
 .TP
 .B \-\-json

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@drakulavich/kesha-voice-kit",
-  "version": "1.25.0",
+  "version": "1.27.0-alpha.1",
   "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": {
@@ -25,7 +25,8 @@
     "SKILL.md",
     "LICENSE",
     "NOTICES.md",
-    "README.md"
+    "README.md",
+    "!src/__tests__"
   ],
   "openclaw": {
     "extensions": [
@@ -57,7 +58,8 @@
     "check:workflows": "bun .github/scripts/check-workflows.ts",
     "check:specs": "bunx @fission-ai/openspec@1.4.1 validate --specs --strict",
     "check:release-manifest": "bun .github/scripts/release-manifest.mjs --check",
-    "check:versions": "bun .github/scripts/check-versions.ts"
+    "check:versions": "bun .github/scripts/check-versions.ts",
+    "check:engine-targets": "bun .github/scripts/check-engine-targets.ts"
   },
   "keywords": [
     "asr",
@@ -102,6 +104,7 @@
   },
   "overrides": {
     "hono": "^4.12.25",
-    "fast-uri": "^3.1.3"
+    "fast-uri": "^3.1.5",
+    "ip-address": "^10.3.1"
   }
 }

package/src/cli/init.ts

@@ -1,11 +1,15 @@
 import { defineCommand } from "citty";
-import { createInterface } from "node:readline/promises";
-import { stdin as input, stdout as output } from "node:process";
-import { multiselect, isCancel, cancel } from "@clack/prompts";
+import { confirm, multiselect, isCancel, cancel } from "@clack/prompts";
 import { renderInstallPlan } from "../install-plan";
 import { log } from "../log";
 import { getEngineCapabilities } from "../engine";
-import { performInstall, resolveBackendFlag, resolveNoCacheFlag, TTS_LANG_FALLBACK } from "./install";
+import {
+  performInstall,
+  resolveBackendFlag,
+  resolveNoCacheFlag,
+  TTS_LANG_FALLBACK,
+  unavailableBackendError,
+} from "./install";
 import type { SharedInstallArgs } from "./types";
 
 const TTS_LANG_LABELS: Record<string, string> = {
@@ -23,6 +27,18 @@ const TTS_LANG_LABELS: Record<string, string> = {
 /** Signature of the interactive TTS-language picker (injectable for tests). */
 export type TtsLangPrompt = (preselect: string[]) => Promise<string[]>;
 
+/** Signature of the interactive yes/no prompt (injectable for tests). */
+export type ConfirmPrompt = (message: string, initialValue: boolean) => Promise<boolean>;
+
+/** Ctrl-C at any prompt ends init without downloading, rather than falling through with a default. */
+function exitIfCancelled<T>(answer: T | symbol): T {
+  if (isCancel(answer)) {
+    cancel("Init cancelled.");
+    process.exit(0);
+  }
+  return answer as T;
+}
+
 async function promptTtsLangs(preselect: string[]): Promise<string[]> {
   const caps = await getEngineCapabilities();
   const supported = caps?.tts?.languages.map((l) => l.code) ?? TTS_LANG_FALLBACK;
@@ -33,11 +49,12 @@ async function promptTtsLangs(preselect: string[]): Promise<string[]> {
     initialValues: preselect.filter((l) => supported.includes(l)),
     required: false,
   });
-  if (isCancel(selected)) {
-    cancel("Init cancelled.");
-    process.exit(0);
-  }
-  return selected as string[];
+  return exitIfCancelled(selected);
+}
+
+/** #677: keep every prompt on clack — its close() unpipes stdin, deadlocking any readline sharing it. */
+async function promptConfirm(message: string, initialValue: boolean): Promise<boolean> {
+  return exitIfCancelled(await confirm({ message, initialValue }));
 }
 
 export interface InitCommandArgs extends SharedInstallArgs {
@@ -52,10 +69,6 @@ export interface InitSelection {
   diarize: boolean;
 }
 
-interface PromptApi {
-  question(prompt: string): Promise<string>;
-}
-
 export function canInstallDiarizeOnPlatform(
   platform = process.platform,
   arch = process.arch,
@@ -140,17 +153,17 @@ export function renderInitOverview(canDiarize = canInstallDiarizeOnPlatform()):
 
 export async function promptInitSelection(
   args: InitCommandArgs,
-  prompt: PromptApi,
+  prompt: ConfirmPrompt,
   backend = resolveBackendFlag(args.coreml, args.onnx),
   canDiarize = canInstallDiarizeOnPlatform(),
   noCache = resolveNoCacheFlag(args),
   promptTts: TtsLangPrompt = promptTtsLangs,
 ): Promise<InitSelection> {
   const ttsLangs = await promptTts(args.tts ? ["en"] : []);
-  const vad = await askYesNo(prompt, "Install VAD for long or silence-heavy audio?", args.vad);
+  const vad = await prompt("Install VAD for long or silence-heavy audio?", args.vad);
   let diarize = false;
   if (canDiarize) {
-    diarize = await askYesNo(prompt, "Install speaker diarization for `--speakers`?", args.diarize);
+    diarize = await prompt("Install speaker diarization for `--speakers`?", args.diarize);
   } else if (args.diarize) {
     log.warn("--diarize is currently darwin-arm64 only; omitting it from the interactive install.");
   }
@@ -164,18 +177,14 @@ export async function promptInitSelection(
   };
 }
 
-async function askYesNo(prompt: PromptApi, message: string, defaultValue: boolean): Promise<boolean> {
-  const suffix = defaultValue ? "Y/n" : "y/N";
-  for (;;) {
-    const answer = (await prompt.question(`${message} [${suffix}] `)).trim().toLowerCase();
-    if (answer === "") return defaultValue;
-    if (answer === "y" || answer === "yes") return true;
-    if (answer === "n" || answer === "no") return false;
-    log.warn("Please answer yes or no.");
+/** 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);
+  if (backendError) {
+    log.error(backendError);
+    process.exitCode = 2;
+    return false;
   }
-}
-
-async function printPlan(selection: InitSelection): Promise<void> {
   log.info(
     await renderInstallPlan({
       noCache: selection.noCache,
@@ -185,6 +194,7 @@ async function printPlan(selection: InitSelection): Promise<void> {
       diarize: selection.diarize,
     }),
   );
+  return true;
 }
 
 async function runNonInteractive(selection: InitSelection): Promise<void> {
@@ -194,7 +204,7 @@ async function runNonInteractive(selection: InitSelection): Promise<void> {
     log.warn("--diarize is currently darwin-arm64 only; omitting it from non-interactive examples.");
   }
   log.info(renderInitOverview(canDiarize));
-  await printPlan(printableSelection);
+  if (!(await printPlan(printableSelection))) return;
   log.info("Run one of these commands from an interactive terminal:");
   for (const command of initSuggestionCommands(printableSelection, canDiarize)) {
     log.info(`  ${command.join(" ")}`);
@@ -264,13 +274,7 @@ export const initCommand = defineCommand({
       if (selection.diarize && !installSelection.diarize) {
         log.warn("--diarize is currently darwin-arm64 only; omitting it from the --yes install.");
       }
-      await performInstall(
-        installSelection.noCache,
-        installSelection.backend,
-        installSelection.ttsLangs,
-        installSelection.vad,
-        installSelection.diarize,
-      );
+      await performInstall(installSelection);
       return;
     }
 
@@ -282,33 +286,30 @@ export const initCommand = defineCommand({
     }
 
     log.info(renderInitOverview());
-    const rl = createInterface({ input, output });
-    try {
-      const prompted = await promptInitSelection(args, rl, backend, canInstallDiarizeOnPlatform(), noCache);
-      log.info("");
-      await printPlan(prompted);
-      const confirmed = await askYesNo(rl, `Run \`${initInstallArgs(prompted).join(" ")}\` now?`, true);
-      if (!confirmed) {
-        log.info(`Skipped install. Run later: ${initInstallArgs(prompted).join(" ")}`);
-        return;
-      }
-      await performInstall(
-        prompted.noCache,
-        prompted.backend,
-        prompted.ttsLangs,
-        prompted.vad,
-        prompted.diarize,
-      );
-      // Next-steps hint (#523): leave the user with something runnable rather
-      // than ending on the install log.
-      log.info("");
-      log.success("Kesha is ready. Try:");
-      log.info("  kesha path/to/audio.ogg     Transcribe a file.");
-      if (prompted.ttsLangs.length > 0) {
-        log.info('  kesha say "hello"           Speak text (TTS).');
-      }
-    } finally {
-      rl.close();
+    const prompted = await promptInitSelection(
+      args,
+      promptConfirm,
+      backend,
+      canInstallDiarizeOnPlatform(),
+      noCache,
+    );
+    log.info("");
+    if (!(await printPlan(prompted))) return;
+    const confirmed = await promptConfirm(
+      `Run \`${initInstallArgs(prompted).join(" ")}\` now?`,
+      true,
+    );
+    if (!confirmed) {
+      log.info(`Skipped install. Run later: ${initInstallArgs(prompted).join(" ")}`);
+      return;
+    }
+    await performInstall(prompted);
+    // #523: end on something runnable, not on the install log.
+    log.info("");
+    log.success("Kesha is ready. Try:");
+    log.info("  kesha path/to/audio.ogg     Transcribe a file.");
+    if (prompted.ttsLangs.length > 0) {
+      log.info('  kesha say "hello"           Speak text (TTS).');
     }
   },
 });

package/src/cli/install.ts

@@ -1,17 +1,22 @@
 import { defineCommand } from "citty";
 import { errorMessage } from "../error-utils";
-import { downloadEngine } from "../engine-install";
+import { installEngine } from "../engine-install";
+import { engineTarget } from "../engine-targets";
 import { getEngineBinPath, getEngineCapabilities } from "../engine";
 import { renderInstallPlan } from "../install-plan";
 import { maybeAskForStar } from "../star";
 import { log } from "../log";
 import { packageVersion } from "../package-info";
+import { isSemver } from "../semver.mjs";
 import { createDiagnosticLogSession, type DiagnosticLogSession } from "../diagnostic-log";
 import type { SharedInstallArgs } from "./types";
 
 export interface InstallCommandArgs extends SharedInstallArgs {
   /** Positional args after `install` — candidate TTS language codes. */
   _?: string[];
+  /** `init` deliberately has no such flag: an override is an expert action, not a guided one. */
+  "engine-version"?: string;
+  engineVersion?: string;
 }
 
 /**
@@ -56,6 +61,23 @@ export function resolveTtsLangs(input: TtsArgInput, supported: string[] | undefi
   return langs;
 }
 
+/**
+ * Validates `--engine-version` before any network call. Returns undefined when the flag is
+ * absent, so the Pinned Engine version stays the default; throws on anything the version
+ * drift gate would not accept either — one SemVer 2.0 definition across the repo.
+ */
+export function resolveEngineVersionFlag(raw: unknown): string | undefined {
+  if (raw === undefined || raw === null || raw === false) return undefined;
+  const value = String(raw).trim();
+  if (isSemver(value)) return value;
+  const hint = /^v\d/.test(value)
+    ? ' Drop the leading "v" — that belongs to the release tag, not the version.'
+    : "";
+  throw new Error(
+    `--engine-version needs an exact SemVer 2.0 version like 1.24.8 or 1.24.8-alpha.1, got "${value}".${hint}`,
+  );
+}
+
 export function resolveNoCacheFlag(
   args: Pick<InstallCommandArgs, "no-cache" | "noCache" | "no_cache">,
   rawArgs: string[] = [],
@@ -90,10 +112,11 @@ export function resolveBackendFlag(coreml: boolean, onnx: boolean): string | und
   return selection.backend;
 }
 
-function defaultBackendForPlatform(): string | undefined {
-  if (process.platform === "darwin" && process.arch === "arm64") return "coreml";
-  if (process.platform === "linux" && process.arch === "x64") return "onnx";
-  return undefined;
+export function defaultBackendForPlatform(
+  platform: string = process.platform,
+  arch: string = process.arch,
+): string | undefined {
+  return engineTarget(platform, arch)?.backend;
 }
 
 type InstallDiagnosticErrorKind = "validation_failed" | "install_failed";
@@ -118,16 +141,42 @@ function finishInstallDiagnostic(
   }
 }
 
-export async function performInstall(
-  noCache: boolean,
-  backend: string | undefined,
-  ttsLangs: string[],
-  vad = false,
-  diarize = false,
-  plan = false,
-) {
+/** 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();
+  if (!backend || process.env.KESHA_ENGINE_BIN || !platformBackend) return null;
+  if (backend === platformBackend) return null;
+  return (
+    `Requested backend "${backend}" is not available on this platform; ` +
+    `the release engine uses "${platformBackend}".`
+  );
+}
+
+export interface PerformInstallOptions {
+  noCache: boolean;
+  backend?: string;
+  ttsLangs: string[];
+  vad?: boolean;
+  diarize?: boolean;
+  plan?: boolean;
+  /** Engine release to install instead of the pin, for this invocation only. */
+  engineVersion?: string;
+}
+
+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);
   if (plan) {
-    log.info(await renderInstallPlan({ noCache, backend, ttsLangs, vad, diarize }));
+    if (backendError) {
+      log.error(backendError);
+      process.exitCode = 2;
+      return;
+    }
+    log.info(
+      await renderInstallPlan({ noCache, backend, ttsLangs, vad, diarize, engineVersion }),
+    );
     return;
   }
 
@@ -143,6 +192,7 @@ export async function performInstall(
       tts: ttsLangs.length > 0,
       vad,
       diarize,
+      engineVersionOverride: engineVersion !== undefined,
     });
 
     if (diarize && !(process.platform === "darwin" && process.arch === "arm64")) {
@@ -152,15 +202,11 @@ export async function performInstall(
         "(see https://github.com/drakulavich/kesha-voice-kit/issues/199).",
       );
     }
-    const platformBackend = defaultBackendForPlatform();
-    if (backend && !process.env.KESHA_ENGINE_BIN && platformBackend && backend !== platformBackend) {
+    if (backendError) {
       errorKind = "validation_failed";
-      throw new Error(
-        `Requested backend "${backend}" is not available on this platform; ` +
-          `the release engine uses "${platformBackend}".`,
-      );
+      throw new Error(backendError);
     }
-    await downloadEngine(noCache, backend, { ttsLangs, vad, diarize });
+    await installEngine({ noCache, backend, ttsLangs, vad, diarize, version: engineVersion });
     await maybeAskForStar(getEngineBinPath(), packageVersion, log);
     finishInstallDiagnostic(diagnosticLog, startedAt, "success");
   } catch (err: unknown) {
@@ -212,8 +258,20 @@ export const installCommand = defineCommand({
       description: "Also install the Sortformer streaming-diarization model (~245MB, darwin-arm64 only — #199)",
       default: false,
     },
+    "engine-version": {
+      type: "string",
+      description:
+        "Install this exact engine release instead of the pinned one (expert; the next install returns to the pin)",
+    },
   },
   async run({ args, rawArgs }: { args: InstallCommandArgs; rawArgs: string[] }) {
+    let engineVersion: string | undefined;
+    try {
+      engineVersion = resolveEngineVersionFlag(args["engine-version"] ?? args.engineVersion);
+    } catch (err) {
+      log.error(errorMessage(err));
+      process.exit(2);
+    }
     const backend = resolveBackendFlag(args.coreml, args.onnx);
     const positionals = (args._ ?? []).map(String);
     const caps = await getEngineCapabilities();
@@ -225,13 +283,14 @@ export const installCommand = defineCommand({
       log.error(errorMessage(err));
       process.exit(1);
     }
-    await performInstall(
-      resolveNoCacheFlag(args, rawArgs),
+    await performInstall({
+      noCache: resolveNoCacheFlag(args, rawArgs),
       backend,
       ttsLangs,
-      args.vad,
-      args.diarize,
-      args.plan,
-    );
+      vad: args.vad,
+      diarize: args.diarize,
+      plan: args.plan,
+      engineVersion,
+    });
   },
 });

package/src/cli/status.ts

@@ -26,8 +26,7 @@ export const statusCommand = defineCommand({
   async run({ args }: { args: StatusCommandArgs }) {
     const report = await collectStatus({ disk: args.disk });
     if (args.json) {
-      // `log.*` writes to stdout, so the payload must be the only thing printed —
-      // the setup hint ships inside it instead of on stderr (#647).
+      // `log.*` writes to stdout, so the payload must be the only thing printed (#647).
       console.log(JSON.stringify(report, null, 2));
       return;
     }