@drakulavich/kesha-voice-kit 1.21.0 → 1.22.0-beta.2

package/README.md

@@ -1,5 +1,5 @@
 <p align="center">
-  <img src="https://raw.githubusercontent.com/drakulavich/kesha-voice-kit/main/docs/assets/logo.png" alt="Kesha Voice Kit" width="200">
+  <img src="https://github.com/drakulavich/kesha-voice-kit/raw/main/docs/assets/logo.png" alt="Kesha Voice Kit" width="200">
 </p>
 
 <h1 align="center">Kesha Voice Kit</h1>
@@ -21,7 +21,7 @@
 See [Product positioning](docs/product-positioning.md) for supported workflows, non-goals, maturity labels, and the platform matrix.
 
 <p align="center">
-  <img src="https://raw.githubusercontent.com/drakulavich/kesha-voice-kit/main/demo.gif" alt="kesha demo — English + Russian transcription with automatic language detection" width="800">
+  <img src="https://github.com/drakulavich/kesha-voice-kit/raw/main/demo.gif" alt="kesha demo — English + Russian transcription with automatic language detection" width="800">
 </p>
 
 ## Quick Start
@@ -96,12 +96,13 @@ Each segment gets a `speaker` integer (cluster ID, stable within one file). Linu
 
 ## Text-to-speech
 
-Kesha speaks back via Kokoro-82M (English) and Vosk-TTS (Russian) — voice auto-picks from the text's language. On darwin-arm64, Kokoro uses FluidAudio CoreML instead of ONNX; FluidAudio stores that CoreML cache at `~/.cache/fluidaudio/Models/kokoro`, outside Kesha's pinned model cache:
+Kesha speaks back via Kokoro-82M (English plus selected multilingual voices on Apple Silicon) and Vosk-TTS (Russian) — voice auto-picks from the text's language. On darwin-arm64, Kokoro uses FluidAudio CoreML instead of ONNX; FluidAudio stores that CoreML cache at `~/.cache/fluidaudio/Models/kokoro`, outside Kesha's pinned model cache:
 
 ```bash
 kesha install --tts                      # TTS, opt-in; Darwin Kokoro uses FluidAudio cache
 kesha say "Hello, world" > hello.wav
 kesha say "Привет, мир" > privet.wav     # auto-routes (Milena on darwin, ru-vosk-m02 elsewhere)
+kesha say --voice es-em_alex "Hola, mundo" > hola.wav
 ```
 
 **Output formats** (`--format`, or inferred from `--out` extension):
@@ -269,7 +270,7 @@ mandb ~/.local/share/man 2>/dev/null || true
 
 Compared against Whisper `large-v3-turbo` — all engines auto-detect language.
 
-![Benchmark: openai-whisper vs faster-whisper vs Kesha Voice Kit](https://raw.githubusercontent.com/drakulavich/kesha-voice-kit/main/docs/assets/benchmark.svg)
+![Benchmark: openai-whisper vs faster-whisper vs Kesha Voice Kit](https://github.com/drakulavich/kesha-voice-kit/raw/main/docs/assets/benchmark.svg)
 
 See [BENCHMARK.md](BENCHMARK.md) for the full per-file breakdown (Russian + English).
 
@@ -359,9 +360,65 @@ Add to your client config:
 { "mcpServers": { "kesha": { "command": "kesha", "args": ["mcp"] } } }
 ```
 
-- **Claude Desktop:** `claude_desktop_config.json`
-- **Claude Code:** `claude mcp add kesha -- kesha mcp`
-- **Cursor:** `.cursor/mcp.json`
+Claude Desktop users can place the same JSON in `claude_desktop_config.json`.
+
+<details>
+<summary>Claude Code</summary>
+
+```bash
+claude mcp add kesha -- kesha mcp
+```
+
+</details>
+
+<details>
+<summary>Codex</summary>
+
+Add to `~/.codex/config.toml`:
+
+```toml
+[mcp_servers.kesha]
+command = "kesha"
+args = ["mcp"]
+```
+
+</details>
+
+<details>
+<summary>Gemini CLI</summary>
+
+Add to `~/.gemini/settings.json`:
+
+```json
+{
+  "mcpServers": {
+    "kesha": {
+      "command": "kesha",
+      "args": ["mcp"]
+    }
+  }
+}
+```
+
+</details>
+
+<details>
+<summary>Cursor</summary>
+
+Add to `.cursor/mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "kesha": {
+      "command": "kesha",
+      "args": ["mcp"]
+    }
+  }
+}
+```
+
+</details>
 
 If a tool returns "models not installed", run `kesha install` (ASR) or
 `kesha install --tts` (TTS) once, then retry.
@@ -400,6 +457,10 @@ exit codes, and coarse audio metadata only. They must not store audio,
 transcripts, input text, generated speech text, file names, full paths, raw
 stdout/stderr, environment variables, tokens, or URLs. See [Diagnostic logs](docs/diagnostic-logs.md).
 
+Every user-facing failure prints a stable `error [CODE]: …` line on stderr. See
+[Error codes](docs/errors.md) for the full reference; engine codes are also
+available via `kesha-engine --error-codes-json`.
+
 ## Local Stats privacy and lifecycle
 
 Kesha Stats is disabled by default. When you opt in with `kesha stats enable`,

package/completions/kesha.fish

@@ -67,7 +67,7 @@ complete -c kesha -n '__fish_seen_subcommand_from record' -l debug -d 'Trace eng
 complete -c kesha -n '__fish_seen_subcommand_from say' -l help -d 'Show help'
 complete -c kesha -n '__fish_seen_subcommand_from say' -s h -d 'Show help'
 complete -c kesha -n '__fish_seen_subcommand_from say' -l voice -r -d 'Voice id, e.g. en-am_michael'
-complete -c kesha -n '__fish_seen_subcommand_from say' -l lang -r -d 'BCP 47 language code (default en-us)'
+complete -c kesha -n '__fish_seen_subcommand_from say' -l lang -r -d 'BCP 47 language code (default en-us). With no --voice, routes to that language\'s default voice and skips text-language detection.'
 complete -c kesha -n '__fish_seen_subcommand_from say' -l out -r -d 'Write audio to file instead of stdout'
 complete -c kesha -n '__fish_seen_subcommand_from say' -l rate -r -d 'Speaking rate 0.5–2.0'
 complete -c kesha -n '__fish_seen_subcommand_from say' -l list-voices -d 'List installed voices and exit'

package/completions/kesha.zsh

@@ -99,7 +99,7 @@ _kesha() {
       _arguments '--help[Show help]' \
         '-h[Show help]' \
         '--voice=[Voice id, e.g. en-am_michael]:voice:' \
-        '--lang=[BCP 47 language code (default en-us)]:lang:' \
+        '--lang=[BCP 47 language code (default en-us). With no --voice, routes to that language'\''s default voice and skips text-language detection.]:lang:' \
         '--out=[Write audio to file instead of stdout]:out:' \
         '--rate=[Speaking rate 0.5–2.0]:rate:' \
         '--list-voices[List installed voices and exit]' \

package/docs/diagnostic-logs.md

@@ -91,3 +91,9 @@ kesha logs mode retain-on-failure
 # reproduce the failure
 kesha support-bundle --include-logs --output kesha-support-with-logs.tar.gz
 ```
+
+## Error codes
+
+Failure events record a stable `error_code` field (leak-free by construction).
+The same code is printed to stderr as `error [CODE]: …` and recorded in Stats.
+See [Error codes](errors.md) for the full reference.

package/man/kesha.1

@@ -155,7 +155,7 @@ Trace engine subprocess calls on stderr (or KESHA_DEBUG=1)
 Voice id, e.g. en\-am_michael
 .TP
 .B \-\-lang
-BCP 47 language code (default en\-us)
+BCP 47 language code (default en\-us). With no \-\-voice, routes to that language's default voice and skips text\-language detection.
 .TP
 .B \-\-out
 Write audio to file instead of stdout

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@drakulavich/kesha-voice-kit",
-  "version": "1.21.0",
+  "version": "1.22.0-beta.2",
   "description": "Give your local tools a voice: fast STT in 25 languages (~19x faster than Whisper on Apple Silicon, ONNX CPU fallback), TTS via Kokoro/Vosk/macOS voices, VAD + 107-language detection. Rust engine, Bun CLI, OpenClaw skill.",
   "type": "module",
   "bin": {
@@ -32,7 +32,7 @@
     ]
   },
   "keshaEngine": {
-    "version": "1.21.0"
+    "version": "1.22.0-beta.2"
   },
   "scripts": {
     "test": "bun test",

package/src/__tests__/error-codes-drift.test.ts

@@ -0,0 +1,29 @@
+import { describe, expect, test } from "bun:test";
+import { existsSync, readFileSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+import { join } from "node:path";
+import { KNOWN_TS_CODES } from "../error-codes";
+
+const ENGINE_BIN =
+  process.env.KESHA_ENGINE_BIN ?? join(import.meta.dir, "../../rust/target/release/kesha-engine");
+
+const describeOrSkip = existsSync(ENGINE_BIN) ? describe : describe.skip;
+
+describeOrSkip("error-code drift", () => {
+  test("engine codes ∪ TS-native codes == codes documented in docs/errors.md", () => {
+    const res = spawnSync(ENGINE_BIN, ["--error-codes-json"], { encoding: "utf8" });
+    expect(res.status).toBe(0);
+    const engineCodes: string[] = JSON.parse(res.stdout).map((e: { code: string }) => e.code);
+
+    const known = new Set<string>([...engineCodes, ...KNOWN_TS_CODES]);
+
+    const doc = readFileSync(join(import.meta.dir, "../../docs/errors.md"), "utf8");
+    const documented = new Set<string>();
+    for (const m of doc.matchAll(/`(E_[A-Z0-9_]+)`/g)) documented.add(m[1]);
+
+    // every known code is documented
+    for (const c of known) expect(documented.has(c)).toBe(true);
+    // every documented code is known (no stale doc rows)
+    for (const c of documented) expect(known.has(c)).toBe(true);
+  });
+});

package/src/__tests__/error-codes.test.ts

@@ -0,0 +1,25 @@
+import { describe, expect, test } from "bun:test";
+import { extractEngineErrorCode, TS_NATIVE_CODES, KNOWN_TS_CODES } from "../error-codes";
+
+describe("extractEngineErrorCode", () => {
+  test("extracts the code from a coded engine stderr line", () => {
+    const stderr = "error [E_MODEL_MISSING]: voice 'ru-vosk-m02' not installed. run: kesha install --tts";
+    expect(extractEngineErrorCode(stderr)).toBe("E_MODEL_MISSING");
+  });
+
+  test("extracts even when the message embeds a path or token", () => {
+    const stderr = "warning: foo\nerror [E_BAD_AUDIO]: decode error in: /Users/alice/secret-token-abc.wav";
+    expect(extractEngineErrorCode(stderr)).toBe("E_BAD_AUDIO");
+  });
+
+  test("returns undefined for an uncoded stderr so caller can fall back", () => {
+    expect(extractEngineErrorCode("Error: something went wrong")).toBeUndefined();
+  });
+
+  test("TS-native codes are exposed and included in KNOWN_TS_CODES", () => {
+    expect(TS_NATIVE_CODES.INPUT_NOT_FOUND).toBe("E_INPUT_NOT_FOUND");
+    expect(TS_NATIVE_CODES.ENGINE_SPAWN).toBe("E_ENGINE_SPAWN");
+    expect(TS_NATIVE_CODES.INVALID_ARG).toBe("E_INVALID_ARG");
+    expect(KNOWN_TS_CODES.has("E_INTERNAL")).toBe(true);
+  });
+});

package/src/__tests__/stats-error-codes.test.ts

@@ -0,0 +1,14 @@
+import { describe, expect, test } from "bun:test";
+import { SayError } from "../synth";
+
+describe("SayError carries a taxonomy code", () => {
+  test("pre-check throws carry text codes", () => {
+    const e = new SayError("text is empty", 2, "", "E_TEXT_EMPTY");
+    expect(e.code).toBe("E_TEXT_EMPTY");
+    expect(e.exitCode).toBe(2);
+  });
+  test("defaults to E_INTERNAL when unspecified", () => {
+    const e = new SayError("boom", 4, "");
+    expect(e.code).toBe("E_INTERNAL");
+  });
+});

package/src/cli/main.ts

@@ -20,6 +20,7 @@ import { getPendingSignalExitCode, waitForPendingSignalCleanup } from "../proces
 import type { TranscriptionSegment } from "../types";
 import { createDiagnosticLogSession } from "../diagnostic-log";
 import { diagnosticSizeBucket } from "../diagnostic-events";
+import { ENGINE_CODES, extractEngineErrorCode, TS_NATIVE_CODES } from "../error-codes";
 
 interface MainCommandArgs {
   _: string[];
@@ -301,9 +302,12 @@ export const mainCommand = defineCommand({
     for (const file of files) {
       if (!existsSync(file)) {
         hasError = true;
-        stats.recordError("input", new Error("File not found"), "file_not_found");
-        diagnosticLog.event("input.missing", { command: "transcribe" });
-        errors.push({ file, code: "file_not_found", message: "File not found" });
+        stats.recordError("input", new Error("File not found"), TS_NATIVE_CODES.INPUT_NOT_FOUND);
+        diagnosticLog.event("input.missing", {
+          command: "transcribe",
+          error_code: TS_NATIVE_CODES.INPUT_NOT_FOUND,
+        });
+        errors.push({ file, code: TS_NATIVE_CODES.INPUT_NOT_FOUND, message: "File not found" });
         log.error(`${file}: File not found`);
         continue;
       }
@@ -404,14 +408,17 @@ export const mainCommand = defineCommand({
       } catch (err: unknown) {
         progress?.stop();
         hasError = true;
-        stats.recordError("transcribe", err);
+        const stderrText = err instanceof Error ? err.message : String(err);
+        const code = extractEngineErrorCode(stderrText) ?? ENGINE_CODES.TRANSCRIBE_FAILED;
+        stats.recordError("transcribe", err, code);
         diagnosticLog.event("engine.exit", {
           command: "transcribe",
           status: "failed",
           errorKind: "transcribe_failed",
+          error_code: code,
         });
-        const message = err instanceof Error ? err.message : String(err);
-        errors.push({ file, code: "transcribe_failed", message });
+        const message = stderrText;
+        errors.push({ file, code, message });
         log.error(`${file}: ${message}`);
       }
     }

package/src/cli/say.ts

@@ -14,6 +14,25 @@ async function autoRouteVoice(text: string): Promise<string | undefined> {
   return pickVoiceForLang(detected?.code, detected?.confidence ?? 0);
 }
 
+/**
+ * Resolve the voice for `kesha say`. Precedence: explicit `--voice` > explicit
+ * `--lang` (route by the stated language, skipping detection — also the path on
+ * Linux/Windows where text-language detection is unavailable) > macOS
+ * text-language auto-detection > engine default (`undefined`). A `--lang` with
+ * no mapped voice (an unsupported language, or French which has no male Kokoro
+ * voice) resolves to `undefined` (engine default) rather than re-running
+ * detection — the user stated the language explicitly.
+ */
+export async function resolveSayVoice(
+  explicitVoice: string | undefined,
+  langHint: string | undefined,
+  text: string,
+): Promise<string | undefined> {
+  if (explicitVoice !== undefined) return explicitVoice;
+  if (langHint !== undefined) return pickVoiceForLang(langHint, 1);
+  return autoRouteVoice(text);
+}
+
 /** Resolve the text to synthesize: inline positional, else read from stdin. */
 async function resolveText(inline: string | undefined): Promise<string> {
   if (inline !== undefined && inline.length > 0) return inline;
@@ -89,7 +108,11 @@ export const sayCommand = defineCommand({
   args: {
     text: { type: "positional", required: false, description: "Text to speak (stdin if omitted)" },
     voice: { type: "string", description: "Voice id, e.g. en-am_michael" },
-    lang: { type: "string", description: "BCP 47 language code (default en-us)" },
+    lang: {
+      type: "string",
+      description:
+        "BCP 47 language code (default en-us). With no --voice, routes to that language's default voice and skips text-language detection.",
+    },
     out: { type: "string", description: "Write audio to file instead of stdout" },
     rate: { type: "string", description: "Speaking rate 0.5–2.0", default: "1.0" },
     "list-voices": { type: "boolean", description: "List installed voices and exit" },
@@ -183,12 +206,13 @@ export const sayCommand = defineCommand({
     }
     const text = await resolveText(inlineText);
     const explicitVoice = typeof args.voice === "string" ? args.voice : undefined;
-    const voice = explicitVoice ?? (await autoRouteVoice(text));
+    const langHint = typeof args.lang === "string" ? args.lang : undefined;
+    const voice = await resolveSayVoice(explicitVoice, langHint, text);
 
     const opts = {
       text,
       voice,
-      lang: typeof args.lang === "string" ? args.lang : undefined,
+      lang: langHint,
       out: typeof args.out === "string" ? args.out : undefined,
       rate,
       ssml: Boolean(args.ssml),
@@ -250,13 +274,15 @@ export const sayCommand = defineCommand({
       stats.finish("success", 1);
       diagnosticLog.finish("success");
     } catch (err) {
-      stats.recordError("tts", err);
+      const code = err instanceof SayError ? err.code : "E_INTERNAL";
+      stats.recordError("tts", err, code);
       stats.finish("failed", 1);
       diagnosticLog.event("command.finish", {
         command: "say",
         status: "failed",
         errorKind: err instanceof SayError ? "say_error" : "error",
         exitCode: err instanceof SayError ? err.exitCode : 4,
+        error_code: code,
       });
       diagnosticLog.finish("failed");
       if (err instanceof SayError) {

package/src/error-codes.ts

@@ -0,0 +1,44 @@
+/**
+ * Error-code taxonomy bridge. The engine is the source of truth for engine
+ * codes (see `kesha-engine --error-codes-json`); these are the codes that
+ * originate in TS, before/around the engine. See
+ * `docs/superpowers/specs/2026-05-30-structured-error-taxonomy-design.md`.
+ */
+
+/** Matches the engine's `error [CODE]:` line; CODE charset is constrained. */
+const ENGINE_CODE_RE = /^error \[([A-Z0-9_]+)\]:/m;
+
+/** Extract the engine error code from captured stderr, if present. */
+export function extractEngineErrorCode(stderr: string): string | undefined {
+  const m = stderr.match(ENGINE_CODE_RE);
+  return m ? m[1] : undefined;
+}
+
+/** Codes that originate in TS (engine never ran, or isn't the failing party). */
+export const TS_NATIVE_CODES = {
+  INPUT_NOT_FOUND: "E_INPUT_NOT_FOUND",
+  ENGINE_SPAWN: "E_ENGINE_SPAWN",
+  INVALID_ARG: "E_INVALID_ARG",
+  INTERNAL: "E_INTERNAL",
+} as const;
+
+export type TsNativeCode = (typeof TS_NATIVE_CODES)[keyof typeof TS_NATIVE_CODES];
+
+/**
+ * Engine-owned codes the TS CLI also references by name (e.g. as a fallback
+ * when the engine died without printing an `error [CODE]:` line). These are NOT
+ * TS-native — the engine is the source of truth — so they stay out of
+ * {@link KNOWN_TS_CODES} and the drift test. Named here to avoid bare string
+ * literals scattered through the CLI.
+ */
+export const ENGINE_CODES = {
+  TRANSCRIBE_FAILED: "E_TRANSCRIBE_FAILED",
+} as const;
+
+/** The full set of TS-native codes, for the drift test. */
+export const KNOWN_TS_CODES: ReadonlySet<string> = new Set(Object.values(TS_NATIVE_CODES));
+
+/** Resolve a code from engine stderr, falling back to E_INTERNAL. */
+export function engineErrorCode(stderr: string): string {
+  return extractEngineErrorCode(stderr) ?? TS_NATIVE_CODES.INTERNAL;
+}

package/src/mcp/voices.ts

@@ -60,6 +60,22 @@ function parseVoiceInfo(id: string): VoiceInfo {
     };
   }
 
+  const kokoro = id.match(/^(es|fr|hi|it|ja|pt|zh)-([a-z][fm]_.+)$/);
+  if (kokoro) {
+    const languageCode = kokoro[1];
+    const bareVoice = kokoro[2];
+    const genderChar = bareVoice[1];
+    const gender: "male" | "female" = genderChar === "f" ? "female" : "male";
+    return {
+      voiceId: id,
+      modelId: "kokoro",
+      modelName: "Kokoro-82M",
+      languageCode,
+      languageName: langNameFor(languageCode),
+      gender,
+    };
+  }
+
   if (id.startsWith("macos-")) {
     const m = id.match(/[a-z]{2}-[A-Z]{2}/);
     const languageCode = m ? m[0] : "";

package/src/synth.ts

@@ -5,6 +5,7 @@ import {
   spawnStdioWithDebugFd,
   type EngineCapabilities,
 } from "./engine";
+import { engineErrorCode, TS_NATIVE_CODES } from "./error-codes";
 import { installHint } from "./install-hint";
 import { log } from "./log";
 import { registerProcessTree } from "./process-tree";
@@ -97,6 +98,7 @@ export class SayError extends Error {
     message: string,
     public readonly exitCode: number,
     public readonly stderr: string,
+    public readonly code: string = "E_INTERNAL",
   ) {
     super(message);
     this.name = "SayError";
@@ -110,11 +112,16 @@ export class SayError extends Error {
 export async function say(opts: SayOptions): Promise<Uint8Array> {
   const text = opts.text ?? "";
   if (text.length === 0) {
-    throw new SayError("text is empty", 2, "");
+    throw new SayError("text is empty", 2, "", "E_TEXT_EMPTY");
   }
   const chars = Array.from(text).length;
   if (chars > MAX_TEXT_CHARS) {
-    throw new SayError(`text exceeds ${MAX_TEXT_CHARS} chars (${chars})`, 5, "");
+    throw new SayError(
+      `text exceeds ${MAX_TEXT_CHARS} chars (${chars})`,
+      5,
+      "",
+      "E_TEXT_TOO_LONG",
+    );
   }
 
   if (!isEngineInstalled()) {
@@ -122,6 +129,7 @@ export async function say(opts: SayOptions): Promise<Uint8Array> {
       `kesha-engine not installed. run: ${installHint("--tts")}`,
       1,
       "",
+      TS_NATIVE_CODES.ENGINE_SPAWN,
     );
   }
   const capabilities = opts.noExpandAbbrev ? await getEngineCapabilities() : null;
@@ -176,6 +184,7 @@ export async function say(opts: SayOptions): Promise<Uint8Array> {
       stderrText.trim() || `kesha-engine say exited ${exitCode}`,
       exitCode,
       stderrText,
+      engineErrorCode(stderrText),
     );
   }
   return new Uint8Array(stdoutBuf);

package/src/types.ts

@@ -19,7 +19,13 @@ export type TranscribeResult = {
 
 export type TranscribeErrorRecord = {
   file: string;
-  code: "file_not_found" | "transcribe_failed";
+  /**
+   * Taxonomy error code. The canonical set lives in Rust and is documented in
+   * `docs/errors.md`; we type it as `string` so the precise engine code (e.g.
+   * `E_DIARIZE_TIMEOUT`, `E_MODEL_MISSING`) flows through to `--include-errors`
+   * output instead of being collapsed to a narrow union.
+   */
+  code: string;
   message: string;
 };
 

package/src/voice-routing.ts

@@ -5,19 +5,35 @@
  */
 const RU_DARWIN_FALLBACK_VOICE = "macos-com.apple.voice.compact.ru-RU.Milena";
 
+const DARWIN_KOKORO_DEFAULTS: Record<string, string> = {
+  es: "es-em_alex",
+  hi: "hi-hm_omega",
+  it: "it-im_nicola",
+  ja: "ja-jm_kumo",
+  pt: "pt-pm_alex",
+  zh: "zh-zm_yunjian",
+};
+
 /** Map a detected language code to a default voice id. Unknown / low-confidence → undefined. */
 export function pickVoiceForLang(
   code: string | undefined,
   confidence: number,
   platform: NodeJS.Platform = process.platform,
+  arch: NodeJS.Architecture = process.arch,
 ): string | undefined {
   if (!code || confidence < 0.5) return undefined;
-  switch (code) {
+  const baseCode = code.toLowerCase().split(/[-_]/, 1)[0];
+  switch (baseCode) {
     case "en":
       return "en-am_michael";
     case "ru":
+      // AVSpeech Milena is a macOS system voice (any arch); Vosk elsewhere.
       return platform === "darwin" ? RU_DARWIN_FALLBACK_VOICE : "ru-vosk-m02";
     default:
+      // Multilingual Kokoro voices ship only on darwin-arm64 (FluidAudio ANE).
+      // Intel Macs have no such voice pack, so don't auto-route to ids the
+      // engine can't honour — fall through to the engine default instead.
+      if (platform === "darwin" && arch === "arm64") return DARWIN_KOKORO_DEFAULTS[baseCode];
       return undefined;
   }
 }