C-Kernel-Engine / TTS bring-up

Kokoro TTS bring-up

Current generated execution status

Long-document planning, asset-free contract: version/v8/tts/prepare_kokoro_document.py partitions up to 1,000,000 UTF-8 bytes at checked sentence or whitespace boundaries, delegates every window to the existing pinned Kokoro text planner, and maps every speech chunk back to an absolute original-document span. It rejects unsupported windows and changed frontend/bundle identities before playback. ck_kokoro_play.py --incremental --document then uses the existing bounded audio spool and keeps its native worker loaded across document chunks. The source-coverage test includes a synthetic document over 10,000 words; it does not claim that a real 10,000-word document was synthesized or heard. An optional private progress file records only chunks whose player has exited successfully. --resume rechecks document, seed, frontend, voice and bundle identities, then restarts at the next chunk. An interrupted sentence may replay when its completion was not acknowledged. Audio files stay in a bounded temporary spool; the whole document WAV is never held in memory. Continuous listening is not certified while synthesis may be slower than audio playback. For a local asset-backed trial, use ck_kokoro_play.py --incremental --document --text-file DOCUMENT --config CONFIG --bundle-dir BUNDLE --player PLAYER --progress-file PROGRESS --session-id DOCUMENT-SESSION, adding --resume after an interruption. Keep a new report path for each invocation. Run python3 scripts/nightly_runner.py --tests tts_kokoro_document_plan tts_kokoro_voice_playback for the asset-free contracts. A real Sony headset trial and connected waveform parity remain separate gates.

Local accessible voice control, first slice: version/v8/scripts/ck_accessible_voice.py can explicitly record a 16 kHz mono WAV from a selected ALSA input, run CKE Whisper, show an editable transcript, require confirmation, submit it to one local CKE Responses server, and speak the correlated answer through a local system-voice command. The client journals submission intent before network delivery and distinguishes a server acceptance ID, completion, explicit rejection and uncertain delivery. It never retries uncertain delivery automatically. The system voice is announced and can be stopped or repeated; this is not Kokoro or Qwen generated speech. The local request targets one configured CKE chat server. It does not route to coding-agent sessions or establish a LinuxUtilities integration.

python3 version/v8/scripts/ck_accessible_voice.py \
  --record --capture-device <explicit-ALSA-Sony-source> \
  --encoder-run-dir <Whisper-encoder-run-dir> \
  --decoder-run-dir <Whisper-decoder-run-dir> \
  --server-url http://127.0.0.1:8080 --model ck-v8 \
  --agent-id cke-chat --project-id cke \
  --journal <private-local-journal.jsonl> \
  --speech-exe <local-system-speech-executable>

Recording starts only after Enter and the temporary microphone WAV is deleted after transcription. --wav accepts an already recorded file; --text exercises the confirmation and server path without audio. The speech executable must accept the answer as one argument and block while speaking. The user must select the desired output device in the local audio configuration. The fake-device/HTTP nightly suite tests control contracts; real Sony input, playback, latency and ten-turn acceptance remain NOT_TESTED.

Whole-text WAV command (bounded, diagnostic): version/v8/tts/speak_kokoro_text.py accepts a text file or standard input, runs one full-context pinned English phonemization pass, and sends its checked chunks to one persistent native host. The host appends only returned valid PCM samples and publishes one 24 kHz mono WAV after all chunks succeed. It discards partial output after a rejected chunk; the next sequence can run without reloading weights. Python owns text preparation and chunk requests; circuits and generated C still own all neural stages. This is not streaming playback or certified connected waveform parity. The output remains diagnostic until listening and independent waveform checks pass. Reproduce with PYTHONPATH=<pinned-frontend-site-packages> <pinned-python> version/v8/tts/speak_kokoro_text.py --text-file server_summary.txt --config <pinned-kokoro-config> --bundle-dir <current-runtime-range-bundle> --output /tmp/kokoro-summary.wav --report /tmp/kokoro-summary.json. A bundle built before persistent-session support must be rebuilt from the pinned model assets; the command verifies the bundle through its native dispatcher and reports each source span and sample count. Run the cheap contract lane with python3 scripts/nightly_runner.py --tests tts_native_kokoro_wav_host tts_kokoro_whole_text_wav.

Technical decimal pronunciation: The pinned G2P can omit the audible decimal point inside a version-shaped token such as Qwen3.8 and after a leading plus sign such as +3.5. The checked text frontend now records an explicit pronunciation expansion for embedded versions and signed decimals, preserving each original source span and rejecting incomplete pronunciations before synthesis. The 1,133-word technical reply still plans into 316 chunks within the declared ID capacity. In a short, same-model, same-seed generated-audio comparison, CKE Whisper transcribed the old Qwen3.8 bundle. WAV as “Q and 3, 8 bundle” and the expanded WAV as “QN 3.8 bundle.” Both old and new signed-decimal WAVs transcribed as “minus 3.5, not plus 3.5”; this is evidence of a corrected phoneme contract, not a demonstrated ASR improvement for that phrase. The full long-reply WAV and its exact-number score have not been rerun with the changed frontend. Waveform numerical parity and human listening remain separate.

Local Kokoro playback adapter: the confirmed voice client can now select --kokoro-config <pinned-config> --kokoro-bundle-dir <range-bundle> --audio-player <local-player> in place of --speech-exe. It sends the complete answer to CKE's checked whole-text command, verifies its report and PCM WAV before starting the player, and owns both processes in the client's stoppable group. This provides a bounded local playback trial, not streaming audio: the entire WAV is synthesized before playback. Each selected native worker keeps its weights loaded across its assigned chunks of one answer; the adapter starts fresh workers for the next answer. Asset-free playback and invalid-output checks run in standard nightly as tts_kokoro_voice_playback. Sony playback, full-reply latency and connected waveform parity remain separate acceptance gates.

Native Kokoro VTune profile (2026-11-06): Profiling two generated native requests on an Intel i7-14700T, with the pinned af_heart bundle and the selected eight-worker AVX2 Conv1D provider, produced the same WAV hashes as the unprofiled session. VTune attributed 34.9% of sampled CPU time to Conv1D, 25.5% to checked linear projections, and 13.2% to dense transposed convolution. The P-core top-down sample reported 7.1% memory bound and 36.1% core bound; these figures identify a compute-focused experiment on this host, not a general roofline conclusion. The next bounded experiment is an explicitly selected reusable linear provider, benchmarked against the existing scalar FP64 reduction contract with complete-WAV and rejection parity. No performance improvement or headset result is claimed by this profile. The retained measurements and limitations are in version/v8/tts/evidence/kokoro_vtune_native_hotspots_20261106.json.

Checked linear one-pass optimization: The reusable FP64 linear provider now checks all inputs and a conservative absolute output bound before computing each output once. When the bound cannot prove safety, the original two-pass result staging remains; rejected calls still leave output untouched. On the pinned 36-by-128-to-768 projection fixture, median kernel time fell from 4.2248 to 2.1458 ms with bitwise-identical output. Two paired native Kokoro sessions using the same loaded model package, voice, seeds and phoneme IDs took 13.5087/13.4525 seconds before and 11.1428/11.0564 seconds after, a 17.66% reduction in median elapsed time. Both complete WAV hashes matched exactly. These are two samples on one Intel host, not a long-document or headset latency result. Evidence and limitations are retained in version/v8/tts/evidence/kokoro_linear_one_pass_20261106.json.

Incremental long-reply execution: --kokoro-incremental keeps the existing one-worker path by default. --kokoro-synthesis-workers 3 opts into three independently loaded native workers for a long reply. The adapter submits at most one checked chunk per worker, validates each 24 kHz PCM16 WAV, retains source spans and WAV hashes, and plays chunks in source order. It reports first playback start, valid samples, gaps and actual model loads through ck_kokoro_play.py --report <private-report.json>. A failed chunk stops publication; SIGTERM during synthesis or playback kills the owned workers and player. The planner retains its 8,192-byte and 512-chunk bounds.

Incremental reader identity: Each completed chunk report now binds its checked source-codepoint span and source text to the whole-source SHA-256, bundle identity, optional agent/request/session IDs, and start/end sample offsets in the concatenated PCM timeline. Resume keeps the prior completed-sample offset and rejects a changed agent or request identity. The optional IDs are limited to letters, digits, underscore and hyphen; both must be supplied together. This gives a reader enough identity to reject late audio or stale highlighted text from an older reply. These offsets describe generated PCM order, not measured audible onset; headset timing still requires a device-backed trial. On 2026-11-07 the current 319-word server_summary.txt (SHA-256 a0134675eadebe16ebc938eb70213fe6eb84630c5505ca979b90fe592eec5a18) planned into 87 checked chunks spanning every source character with 5–40 phoneme IDs per chunk. This is a planning PASS; P3 synthesis and Sony playback were NOT_TESTED because p3 did not resolve from this host. The plan identity and limits are retained in version/v8/tts/evidence/kokoro_319word_summary_plan_20261107.json.

Playback stop and latency diagnostics: The incremental player and each native worker now run in private process groups. Cancellation stops the groups, including audio or synthesis children started by wrappers. Asset-free regressions verify that parent and child processes stop. The report separates planning, native-worker startup, synthesis underrun gaps, controller/player handoff delay, and player-process lifetime. first_playback_start_seconds is a process-launch timestamp, not a measured first audible sample; the report explicitly marks first_audible_audio as not_measured. Real headset listening and audible stop latency still need device-backed measurement. On this Intel i7-14700T host, a two-chunk generated request produced 5.125 seconds of audio. With a non-audible player timed to each WAV, one loaded worker took 19.130 seconds end to end with a 4.444-second gap, of which 4.443 seconds was synthesis underrun; two loaded workers took 14.976 seconds with a 0.001-second gap. First player launch was 9.408 versus 9.686 seconds, and both chunk WAV hashes matched. These are single observations, not a headset or sustained-throughput certificate. The retained timing report records the bundle and limitations.

On P3 with the eight-worker AVX2 Conv1D bundle, the same 52-word repeated phrase produced 647,400 samples and identical WAV hashes with one or three synthesis workers. Three workers reduced wall time from 68.2 to 36.3 seconds and simulated playback gaps from 32.43 to 0.012 seconds; first playback began at 8.91 versus 8.44 seconds. Peak process-tree PSS rose from 2.83 to 7.60 GiB. A 200-word trial completed 50 ordered chunks, 103.75 audio seconds and 0.051 seconds of simulated gaps. A 1,000-word trial completed 250 contiguous source spans, 12,450,000 samples (518.75 audio seconds) in 532.26 seconds, with 0.256 seconds of total gaps and a 0.0038-second maximum gap. Measured stop-to-process-release times were 0.566 seconds during synthesis and 0.767 seconds during playback, with no live descendants or completion report. The scoped P3 evidence records identities and limits; the earlier one-worker trial remains historical.

The player in these measurements was non-audible and slept for each WAV's exact duration. The input repeated one known phrase; it does not certify natural sentence joins, arbitrary technical text, Sony headset playback, 10,000 words or connected PyTorch waveform parity. That numerical verdict remains FAIL. The three-worker option is an explicit memory tradeoff, not the default accessibility setting.

Technical paths: the pinned G2P left the leading slash in the real server summary unspoken and represented its remaining path as one 230-phoneme token, beyond the 48-ID native request limit. The text frontend now applies an explicit path pronunciation policy before checked chunk planning. Natural mode speaks path components and separator names, spelling a component when its pinned pronunciation exceeds one request; --technical-mode exact spells each path character. A leading slash is spoken as “root slash.” Each pronunciation expansion records its original source span, and every chunk still passes the native ID-capacity check. The current 387-word summary snapshot plans into 111 natural-mode or 116 exact-mode chunks with complete source-span coverage. Natural-mode generated execution played 6,044,400 samples (251.85 audio seconds) through a non-audible duration-matched player in 263.40 seconds wall time, with first simulated playback at 9.27 seconds and 0.131 seconds of total gaps. Use ck_kokoro_play.py --text-file server_summary.txt --config <pinned-config> --bundle-dir <verified-bundle> --player <audio-player> --incremental --synthesis-workers 3; the scoped P3 evidence retains identities and limits without committing the private summary text. This is execution evidence; URL syntax, unsupported symbols, natural listening quality, Sony playback and connected waveform parity remain separate checks. The same mode is available as --kokoro-technical-mode exact in the confirmed voice client.

Measured parallel Conv1D bundle option: the offline bundle builder can select the existing checked avx2_parallel Conv1D map with --conv-provider avx2_parallel --conv-workers 4. The native host creates one worker pool per loaded session and passes it into the circuit-declared generated entry; generic lowering and Kokoro arithmetic are unchanged. On P3, one loaded 64-token-capacity library produced byte-identical serial AVX2 and four-worker WAVs for 25-ID → 8-ID → 25-ID requests. Warm 25-ID synthesis and WAV writing took 11.18 seconds serial versus 6.14 seconds parallel; the 8-ID request took 7.07 versus 3.56 seconds. The build identities, request timings and WAV hashes are retained in the P3 measurement. This remains slower than real time and does not certify pinned-PyTorch waveform parity, headset playback or a 1,000-word trial.

Pinned text preparation and chunk planning: version/v8/tts/prepare_kokoro_accessibility_text.py uses pinned Kokoro 0.9.4/Misaki 0.9.4 English G2P, its US lexicon and eSpeak fallback to turn ordinary text into phoneme-ID requests. It checks code, dictionary, eSpeak library/data, vocabulary and bundle identities; keeps every source span; and rejects unspoken or unsupported input. The first committed reference cases cover the previously rejected “words,” an abbreviation, numbers, technical terms, a list, an equation and a multi-sentence reply. The current pinned frontend leaves the dollar sign in “$1.25” unspoken, so the planner rejects that expression rather than silently speaking a different amount. An opt-in range bundle permits individual requests of 3–48 IDs; the planner records each chunk's source text, IDs and voice row. The cheap fixture test is registered in standard nightly; live pinned-oracle and two-chunk generated-audio checks run only with their assets and otherwise report NOT_TESTED. The two-chunk local run produced 56,400 and 66,600 samples at 24 kHz, with about 14 and 16 seconds of synthesis on that host; these are execution measurements, not a latency target. Reproduce the cheap lane with python3 scripts/nightly_runner.py --tests tts_kokoro_accessibility_text_plan, or enable the live/audio lanes with CKE_TTS_RUN_PINNED_ACCESSIBILITY_TEXT=1 CKE_TTS_RUN_ACCESSIBILITY_TEXT_AUDIO=1 CKE_TTS_ACCESSIBILITY_CONFIG=<pinned-config> CKE_TTS_ACCESSIBILITY_BUNDLE=<range-bundle> python3 -m unittest tests.test_v8_kokoro_accessibility_text_plan in the pinned frontend environment. That older test produces a plan and individual WAVs. The whole-text command above uses one retained native worker and one aggregate WAV. Queued playback, Sony device handling and in-graph cancellation remain unestablished. Connected waveform numerical parity remains FAIL. Python performs declared text conversion only; the model's neural schedule remains in generated C.

Bounded native number preparation: the dictionary frontend now expands isolated unsigned cardinals 0–20 to their English words, then obtains phoneme IDs from the hash-pinned Misaki US gold dictionary. It rejects leading zeros, decimals, grouped digits, larger values, attached letters, unknown words and over-capacity requests with explicit reasons before dispatch. All 21 number spellings have a cheap routing test in standard nightly. In an optional asset-backed lane, “I have 2.” produces a 39,000-sample native generated WAV and CKE's public generated Whisper path returns “I have two.” A second asset-backed session case cancels a longer request, then synthesizes this number phrase twice with the retained seeded WAV hash. These check bounded execution, transcript fidelity, process-level synthesis interruption and recovery; they do not prove full context-sensitive Misaki G2P or independent Kokoro waveform parity. Other abbreviations and longer replies remain unsupported until their normalization and segmentation contracts are verified. Run the optional cases with the standard nightly selection CKE_TTS_RUN_WHISPER_ROUNDTRIP=1 CKE_TTS_RUN_NUMBER_TEXT_FULL=1 CKE_TTS_RUN_NUMBER_SESSION_FULL=1 CKE_TTS_ROUNDTRIP_BUNDLE_DIR=<range-bundle> CKE_TTS_ROUNDTRIP_FRONTEND_DIR=<fresh-number-frontend> CKE_TTS_ROUNDTRIP_WHISPER_ENCODER_DIR=<generated-encoder> CKE_TTS_ROUNDTRIP_WHISPER_DECODER_DIR=<generated-decoder> python3 scripts/nightly_runner.py --tests tts_kokoro_native_speech_session tts_kokoro_whisper_roundtrip.

Opt-in long-token and real-summary P3 trial: a pinned 359-word local summary planned into 90 checked chunks with complete source-span coverage. Normal multi-token chunks stayed at or below 40 IDs; only the indivisible “35,136” number and a commit hash used 48 and 47 IDs. The prior 77-chunk plan had let an ordinary 46-ID phrase reach generated execution, where it returned CK_AUDIO_EXTENT_LIMIT; its partial WAV was discarded. Every revised chunk passed isolated native preflight. One loaded generated session then produced one 4,905,000-sample, 24 kHz mono WAV (204.375 seconds of audio) in 647.011 seconds, including 2.71 seconds of text planning. Selected PCM segments at the first, number, hash and final chunk matched fresh single-request execution byte for byte. The retained evidence records artifact and input hashes; the local summary text itself is not committed. Counts 41–48 remain execution-only; connected PyTorch waveform parity is still FAIL, and headset listening is NOT_TESTED. This run is substantially slower than playback and does not establish 10,000-word support.

Known-text Kokoro → Whisper round trip: an optional asset-backed standard-nightly suite passes the actual native Kokoro WAV through CKE's public audio command to its generated Whisper encoder and decoder. The public entry imports the Whisper runtime by its importable module name so persistent worker processes can start under Python's spawn method. With the pinned af_heart voice and seed 7, “Hello.” (8 phoneme IDs, 32,400 samples) transcribes as “Hello.” and “Hello there.” (12 IDs, 36,000 samples) transcribes as “Hello there.” The suite checks canonical 24 kHz mono PCM16 geometry, input WAV hash, generated-library identities, and exact transcript text after trimming outer whitespace and case-folding. It reports TTS execution, ASR execution, and transcript fidelity as separate cases; missing assets report NOT_TESTED. A separate cheap nightly case tests the public worker import contract without model assets. This is a small known-text integration test, not independent Kokoro waveform parity, a full G2P test, or general speech intelligibility certification. The connected waveform comparisons described below still FAIL their pinned PyTorch numerical ceiling. Run CKE_TTS_RUN_WHISPER_ROUNDTRIP=1 CKE_TTS_ROUNDTRIP_BUNDLE_DIR=<range-bundle> CKE_TTS_ROUNDTRIP_FRONTEND_DIR=<pinned-frontend> CKE_TTS_ROUNDTRIP_WHISPER_ENCODER_DIR=<generated-encoder> CKE_TTS_ROUNDTRIP_WHISPER_DECODER_DIR=<generated-decoder> python3 -m unittest tests.test_v8_kokoro_whisper_roundtrip.

Long technical-reply diagnostic (2026-11-06): The retained version/v8/test_assets/kokoro_long_reply/technical_summary_20261106.txt contains 1,133 varied words, including the then-current 264-word server summary. Its SHA-256 is 0bbca9d04ece5e012929adcd8093f6e8117e2c9e93a6489e54b0c4e65eb4bdf7. The pinned planner covered every source span in 316 checked chunks of at most 40 IDs. One persistent generated Kokoro worker produced 667.825 seconds of mono 24 kHz PCM16 audio (SHA-256 6ee6c534329b01d42a40e1f72248d70701a3bd26159c44ba561d69ae5daa5483) in 1,608.12 seconds; the first chunk took 9.33 seconds. Native CKE resampling supplied 16 kHz audio to generated Whisper base. Fixed 30-second decoding returned 766 words and 37.44% normalized WER. Timestamp-seek decoding covered the complete audio in 25 contiguous windows, returning 1,150 words and 6.24% WER under identifier-aware normalization. Exact-number fidelity still FAILS: two 3.8 occurrences were absent, while other unmatched numbers appeared. PR-1035 is treated as an identifier, not a negative number. The small known-text round trip remains separate. version/v8/tts/evaluate_kokoro_whisper_long_reply.py verifies source spans, artifact hashes, resampling linkage, window coverage, WER and exact numbers; its ten asset-free integrity controls run in standard nightly. The full run is diagnostic, with connected Kokoro waveform parity unresolved and human listening NOT_TESTED. The audio and model assets are not committed; their identities are retained in the evaluator report on P3. Timestamp decoding should be used for long-audio diagnosis, and aggregate WER cannot override a critical-number failure.

Long-reply decimal rerun and compound-number boundary: On merged main after explicit version pronunciation, the same 1,133-word source again planned into 316 checked chunks and produced 16,031,400 samples (667.975 seconds) through one persistent generated Kokoro worker in 1,600.95 seconds. The new WAV SHA-256 is 08f4367079ac6710f00504e2ca2c96a13c5d425f6b879f8a34adb80b058a55fc. Its 314 unaffected chunks match the previous WAV byte for byte when aligned by chunk; only the two Qwen3.8 chunks changed. Generated timestamp-mode CKE Whisper consumed the complete resampled audio in 24 windows and returned 1,158 words with 6.15% normalized WER. Both 3.8 occurrences are present, but exact-number fidelity still fails. The remaining text says “forty two” and “forty seven”; the planner split each tens/unit pair across a chunk boundary, and Whisper rendered them as “40, two” and “40. Seven.” The checked planner now keeps such pairs in one chunk. In a same-text, same-model generated-audio comparison, CKE Whisper changed from “40, 2” and “40. 7” to “42” and “47.” The evaluator accepts intact spoken compounds as their digit values while rejecting split or changed values, and checks chunk voice rows, source spans, sample totals and numeric order. The complete document was then regenerated after this second boundary fix: 316 chunks, 16,035,000 samples (668.125 seconds), WAV SHA-256 768df814039b1ec881df554ae138a066ccfcdb746f9869f8920af87981440510, and 1,603.53 seconds of synthesis. Only four boundary-adjacent chunks changed; the other 312 remained byte-identical to the decimal-only run. Generated CKE Whisper consumed all 24 timestamp windows and returned 1,156 words with 6.41% normalized WER. The exact-number sequence now matches the source, with no missing or unexpected values. This is an execution and transcript-fidelity pass, while human listening is not tested in this run and pinned connected waveform parity remains an unresolved failure. The evaluator now requires typed per-chunk metadata and binds each planned text field to its source slice, so matching omissions cannot produce PASS. Its exact-number gate recognizes a bounded signed tens/unit grammar; unsupported higher-order or spoken-decimal constructions are reported as incomplete rather than certified. The 316/317-chunk variation was traced to a second pinned KPipeline construction: its EspeakFallback initialization hit a temporary-library disk-quota error, and Kokoro silently selected a different neural fallback. The frontend now reuses one checked Espeak pipeline per process, pins the Espeak Python adapter identity, and rejects fallback substitution rather than changing phonemes. A pinned long → other request → long replay yields identical phonemes and chunks. The retained WAV remains bound to its hashed 316-chunk plan; first-time Espeak initialization can still fail explicitly when host resources are exhausted.

Current variable-length diagnostic waveform: the circuit now composes the second generator residual pool, final activation, post convolution, magnitude/phase head and inverse STFT after CKE-generated upstream features. One generated native entry returns checked sample counts to a native PCM16 WAV host. The same loaded library is tested with real 8-, 13- and 36-ID af_heart requests and short → intermediate → long → short replay; the 13-ID Hello there. case has an independently captured pinned full-model reference. The 13-ID standalone WAV uses captured Gaussian input; its listenable artifact is tests/fixtures/tts/kokoro_runtime_waveform_hello_there_13_diagnostic.wav, with model, code, generated-library, package and output hashes in version/v8/tts/evidence/kokoro_runtime_waveform_20261018.json. Execution and safety PASS; connected numerical parity FAILS. Eight-, 13- and 36-ID waveform maximum differences are 0.010313, 0.002095 and 0.007652 against direct pinned PyTorch 2.8 captures, under the unchanged 2e-4 diagnostic ceiling. Their waveform RMSE values are 3.38e-4, 8.15e-5 and 2.42e-4 respectively; those aggregate measures do not erase the worst-case failures. The host validates the returned valid sample count separately from its allocated waveform capacity. Set CKE_TTS_RETAIN_DIR=/path/to/output when running the waveform suite to retain the generated library, sparse input package, WAV and reproduction manifest for listening. The native package contains weights and declared external inputs only; the generated entry computes all intermediate neural tensors. This captured-noise lane is a diagnostic phoneme-to-WAV path; the separate native seeded request lane below is not certified arbitrary-text speech. Reproduce with python3 version/v8/tts/build_kokoro_runtime_waveform_circuit.py --check and python3 -m unittest tests.test_v8_kokoro_runtime_waveform; this suite runs in standard nightly.

Native variable-length text trial: the offline bundle builder packages pinned BUMP weights, the af_heart voice bank and one 64-token-capacity generated waveform library. The native dispatcher accepts the separately captured 8-, 13- and 36-ID request lengths and rejects other counts. A small test lexicon reproduces the captured 8-, 13- and 36-ID request tensors. The pinned full US-gold dictionary maps “Hello there.” to an unsupported 12-ID request, which is rejected explicitly; “Hello, there.” maps to a supported 13-ID request and produces a native WAV. The C host selects the corresponding voice row, binds the valid token length, fills request-owned seeded Gaussian noise, and writes only the returned sample count. Local AVX2/FMA text runs produced 32,400, 36,600 and 61,800 samples at 24 kHz; 8 → 13 → 36 → 8 replay matched retained CKE seeded WAV hashes. The speech supervisor has a process-level stop, error and recovery path. Each request starts a new host process, so weights and library mappings are reloaded; persistent loading and headset playback remain future work. These supported phrases demonstrate execution, not arbitrary English coverage or independent waveform parity. Reproduce the bundle with python3 version/v8/tts/build_kokoro_dispatch_bundle.py --bump-dir <pinned-bump> --voice-bank <af-heart.ckvoice> --output-dir <new-bundle> --runtime-lengths --conv-provider avx2_fma, then run the optional asset-backed test with CKE_TTS_RUN_RUNTIME_TEXT_FULL=1 CKE_TTS_RUNTIME_TEXT_BUNDLE_DIR=<new-bundle> python3 -m unittest tests.test_v8_kokoro_native_lexicon_text. The test's small lexicon preserves pinned IDs but does not claim full Misaki context-dependent pronunciation.

Experimental short-text length coverage: the runtime bundle can opt in to individual additional phoneme counts with --runtime-lengths --experimental-count 12, or to the bounded 3–48 count range with --runtime-lengths --runtime-experimental-range. Both modes reuse the same generated 64-token-capacity graph and CKTTS004 package; the builder checks that the pinned voice bank contains every selected row. The default remains 8, 13 and 36 IDs. The bundle manifest separates captured counts from execution-only counts. With the pinned dictionary, “Hello there.” yields 12 IDs and produced two identical native seeded 36,000-sample WAVs using the generated library; the 12-ID waveform hash was 53dc2fa85f9cf190bc59e51689e45206ca213daad87a71f9024c1bc8b5cafa13. This is bounded execution and deterministic replay, not direct pinned-model numerical parity or full English G2P. Unsupported words, counts outside 3–48, and requests exceeding predicted frame/sample capacity still reject. The optional asset-backed test runs through standard nightly when supplied a range bundle and pinned frontend; without them it reports NOT_TESTED with a reason. Reproduce with python3 version/v8/tts/build_kokoro_dispatch_bundle.py --bump-dir <pinned-bump> --voice-bank <af-heart.ckvoice> --output-dir <new-bundle> --runtime-lengths --runtime-experimental-range --conv-provider avx2_fma.

Earlier variable-length second source join: one loaded generated native entry carries 8-ID and 36-ID phoneme requests through the second source convolution, style-conditioned source residual block and join with CKE's own reflected main branch. Both branches consume the checked 6,481/12,361-frame extent with a separate 15,361-frame physical capacity. Short → long → short replay, exact native branch addition, untouched padding, nonfinite-input and over-capacity rejection, and recovery pass. Direct pinned PyTorch 2.8 full-model checkpoints show connected join maximum errors of 0.02531 and 0.04074 under a 2e-4 diagnostic ceiling, so connected numerical parity FAILS. Captured Gaussian remains diagnostic; the second-stage residual pool, spectral head and variable-length WAV remain unfinished. Reproduce with python3 version/v8/tts/build_kokoro_runtime_stage1_source_join_circuit.py --check and python3 -m unittest tests.test_v8_kokoro_runtime_stage1_source_join; the suite is registered in standard nightly.

Earlier variable-length second generator ingress: one loaded generated native entry now carries 8-ID and 36-ID phoneme requests through the first residual pool, second-stage LeakyReLU, checked sixfold dense transposed convolution and one-frame left reflection. The two requests publish 6,480/6,481 and 12,360/12,361 valid deconvolution/reflection frames while preserving separate 15,360/15,361 physical capacities. Short → long → short replay, exact reflected layout, untouched padding, nonfinite-input and over-capacity rejection, and recovery pass. Direct pinned PyTorch 2.8 captures show connected reflection maximum errors of 0.01083 and 0.01718 under a 2e-4 diagnostic ceiling, so connected numerical parity FAILS. Captured Gaussian remains diagnostic; the second-stage residual pool, spectral head and variable-length WAV remain unfinished. Reproduce with python3 version/v8/tts/build_kokoro_runtime_stage1_ingress_circuit.py --check and python3 -m unittest tests.test_v8_kokoro_runtime_stage1_ingress; the suite is registered in standard nightly.

Earlier variable-length first generator residual pool: one generated native entry now continues from phoneme IDs and request-specific af_heart conditioning through the first main/source join, all three first-stage main residual blocks and their three-way mean. The same loaded library runs 8 → 36 → 8 IDs at checked 1,080/2,060-frame extents with a separate 2,560-frame physical capacity. Native sum/mean checks, finite output, untouched mean padding, repeated output, nonfinite-input rejection and recovery pass. Pinned PyTorch 2.8 direct block captures and their explicit mean remain independent oracle evidence: connected mean errors are 0.11312 and 0.23652 maximum under a 2e-4 diagnostic ceiling, so connected numerical parity FAILS. Captured Gaussian remains a diagnostic input; later generator stages and variable-length WAV are unfinished. Reproduce with python3 version/v8/tts/build_kokoro_runtime_stage0_pool_circuit.py --check and python3 -m unittest tests.test_v8_kokoro_runtime_stage0_pool; the suite is registered in standard nightly.

Earlier variable-length first generator join: one generated native entry now runs 8-ID and 36-ID requests from phonemes through the first main upsample, CKE-generated F0, source STFT/convolution, all three first source-residual pairs and the checked main/source sum. The source convolution and residual consumers use the same checked 10× frame extent as the main branch; the duplicate source-frame producer was removed in this circuit. One loaded library passes 8 → 36 → 8 with 1,080 and 2,060 valid join frames, untouched output padding, exact native branch-addition checks, nonfinite-input rejection and recovery. Direct pinned full-model joins still differ by 0.11597 and 0.19440 maximum under a 2e-4 diagnostic ceiling, so connected numerical parity FAILS. Captured Gaussian remains a diagnostic input. This is not a variable-length WAV or certified speech. Reproduce with python3 version/v8/tts/build_kokoro_runtime_stage0_join_circuit.py --check and python3 -m unittest tests.test_v8_kokoro_runtime_stage0_join; the suite is registered in standard nightly.

Earlier variable-length source/STFT boundary: one generated entry now carries 8-ID and 36-ID requests from phonemes through the first main generator upsample, CKE-generated F0, harmonic source, STFT and first source convolution. The same library runs 8 → 36 → 8, publishes checked source, STFT and convolution extents of 32,400/6,481/1,080 and 61,800/12,361/2,060 respectively, leaves capacity padding untouched, and recovers after a rejected nonfinite Gaussian input. Captured Gaussian remains an explicit diagnostic input. Direct pinned full-model comparisons show raw phase differences of approximately 2π and first source-convolution maximum errors of 0.20474 and 0.26074. These are numerical FAIL results, distinct from generated execution and safety PASS; the graph is not a certified source branch or a variable-length WAV. Reproduce with python3 version/v8/tts/build_kokoro_runtime_source_stft_conv_circuit.py --check and python3 -m unittest tests.test_v8_kokoro_runtime_source_stft_conv. The suite is registered in standard nightly.

Earlier variable-length source projection beside the first generator upsample: one generated native entry now executes both branches from request phoneme IDs and supplied af_heart conditioning. CKE's generated F0 drives the harmonic source, linear projection and tanh; the first generator upsample executes in the same entry. The pinned 8-ID and 36-ID requests produce 32,400 and 61,800 source samples, with direct full-model source errors of at most 2.85e-4 and 4.28e-4 under the existing 1e-3 source bound. F0 errors remain below the checkpoint-specific 5e-4 bound. The same loaded library replays 8 → 36 → 8, preserves output padding, rejects nonfinite Gaussian input without publishing lengths, and recovers on a later request. Its F0 tensor retains a 6,400-frame physical capacity while checked source output remains bounded to 76,800 samples. Gaussian input is captured from the pinned reference for arithmetic comparison; native seeded noise, STFT, source residual convolution, branch join, complete variable-length waveform and playback remain separate gates. Reproduce with python3 version/v8/tts/build_kokoro_runtime_source_projection_circuit.py --check and python3 -m unittest tests.test_v8_kokoro_runtime_source_projection; the connected suite runs in standard nightly.

Earlier variable-length first generator upsample: one generated native entry now connects the complete runtime acoustic decoder to the first generator activation and dense transposed convolution. The same loaded library runs 8 → 36 → 8 phoneme-ID requests with af_heart rows 5 → 33 → 5. The checked 2A input extents are 108 and 206; the generated 20A output extents are 1,080 and 2,060, within a declared 2,560-frame output capacity. Direct pinned PyTorch 2.8 full-model captures differ by at most 1.82e-5 and 2.48e-5, respectively, under the 5e-5 stage-specific bound. Output padding remains untouched, and a rejected request publishes no extent before successful recovery. The decoder retains its 6,400-frame physical input stride; generator capacity is separately bounded, so larger requests can be rejected before the upsample writes. This is not the complete waveform generator or a variable-length WAV. Reproduce with python3 version/v8/tts/build_kokoro_runtime_generator_stage0_circuit.py --check and python3 -m unittest tests.test_v8_kokoro_runtime_generator_stage0; the suite is registered in standard nightly.

Earlier variable-length complete acoustic decoder: one capacity-64 circuit runs from phoneme IDs through the complete acoustic decoder, including all four decode blocks and the final A→2A upsampling block, in one generated native entry. The same loaded library runs an 8-ID “Hello.” request (A=54, 2A=108, af_heart row 5), then a 36-ID request (A=103, 2A=206, row 33), then the 8-ID request again. Both lengths use their own direct pinned PyTorch 2.8 full-model decoder captures, with request-specific predictor and decoder styles supplied at the declared input boundary; the largest final-output differences are 3.63e-5 and 2.86e-5 respectively, under the existing checkpoint-specific decoder bounds. The test checks untouched padding, repeatability, invalid lengths, failed style conditioning, recovery, and a deliberately wrong final-block weight. This earlier entry stops at the decoder; voice-row selection within generated execution and complete variable-length waveform generation remain unfinished. The exact-length diagnostic WAV graphs and unresolved connected waveform parity remain separate. Reproduce with python3 -m unittest tests.test_v8_kokoro_runtime_decoder_complete; this suite runs in standard nightly.

Earlier variable-length first acoustic-decoder block: one capacity-64 generated C entry now continues through the first style-conditioned decoder residual block after CKE's own decoder-ingress output. Its normalization, activation, convolution, shortcut, and residual joins consume the checked A valid extent while keeping the 3,200-frame physical stride and capacity separate. One loaded library runs 2 → 36 → 64 → 2 phoneme-ID requests with repeatable short output, untouched padding, rejected invalid style/token count, and recovery. For the pinned 36-ID request (A=103), all six block checkpoints match direct full-model PyTorch hooks under the existing per-checkpoint bounds; the final residual output differs by at most 2.49e-6. X-Ray checks its selected residual contract, valid extent, physical stride, and resolved library identity. Reproduce with python3 -m unittest tests.test_v8_kokoro_runtime_decoder_encode; the suite is registered in standard nightly. Other input lengths have execution and safety evidence only. Decoder style remains pinned to the 36-ID fixture in this test. At this earlier milestone, the rest of the decoder and complete waveform used separately compiled exact-length graphs; the current complete variable-length acoustic decoder is described above. Connected waveform parity remains unresolved.

Earlier variable-length decoder ingress: one capacity-64 generated C entry connects CKE-generated complete F0/noise curves and acoustic text features to both decoder downsampling convolutions, the 514-channel text/F0/noise join, and the 64-channel text residual projection. The circuit binds the checked A and 2A valid extents separately from 3,200/6,400-frame capacity and physical strides. One loaded library handles 2 → 36 → 64 → 2 phoneme-ID requests with preserved padding and repeatable short output. At 36 IDs (A=103, 2A=206), all five outputs match direct pinned full-model hooks under their existing per-checkpoint bounds; the largest error is 1.57e-5. Wrong-weight and failed-provider controls check that bad connections are detected and failed calls publish no lengths. Reproduce with python3 -m unittest tests.test_v8_kokoro_runtime_decoder_ingress; the suite is registered in standard nightly. Other ID lengths have execution and safety evidence only.

Earlier runtime-length boundary (complete prosody): one capacity-64 generated C entry now runs from phoneme IDs and pinned voice conditioning through both complete F0 and noise branches. The checked A frame count drives both first residual blocks; a checked A→2A operation validates the output extent before the second blocks and final projections write. The planner reserves for at most 3,200 A frames and 6,400 output frames, while valid extents and physical strides remain distinct. The test arena is 542,225,664 bytes. One loaded library executes 2 → 36 → 64 → 2 ID requests with repeatable short output, untouched output padding, failure propagation and recovery. For the 36-ID request, A=103 and 2A=206; direct pinned full-model PyTorch hooks differ by at most 3.52e-6 and 2.99e-6 after the first F0/noise residual blocks, and 3.25e-4 and 5.25e-6 at the complete F0/noise outputs, under 1e-4 first-block bounds and final-output bounds of 5e-4 for F0 and 1e-4 for noise. Other ID lengths have execution and safety evidence, not direct complete-prosody oracle parity. The subsequent decoder-ingress circuit extends this variable-length graph through input preparation; the remaining acoustic decoder, source and waveform generator still use separately compiled exact-length graphs. The selected style vector remains the pinned 36-ID fixture selection in this test. Reproduce with python3 -m unittest tests.test_v8_kokoro_runtime_prosody_complete; the suite runs in standard nightly.

Current waveform boundary: two explicitly compiled, exact-length af_heart graphs produce complete generated native waveforms: an 8-ID “Hello.” capture yields 32,400 samples and the established 36-ID capture yields 61,800 samples, both at 24 kHz. The same process keeps both generated libraries loaded and replays short → long → short without compiling per request; the repeated short FP32 waveform is exact. A capacity rejection leaves the short output and published lengths untouched, and the next short request succeeds. The standalone C host writes a 24 kHz PCM16 WAV for each exact length; the new short WAV matches the in-process generated samples after PCM conversion. The eight-ID asset-backed test also generates request-seeded Gaussian noise in CKE, then compares the native host's PCM with the same seeded generated entry. That checks short-graph standalone replay without claiming PyTorch RNG or waveform parity. These are separate arenas and exact token counts, not a single runtime-valid-length graph or a padding/masking bucket policy. The captured-noise fixture supplies already-selected voice vectors; the CKTTS003 native host described below selects the voice-bank row before generated execution. A separate asset-backed check confirms that the eight-ID and 36-ID vectors exactly match rows 5 and 33 of the hash-pinned af_heart bank. Connected waveform numerical parity still fails against the pinned full model (maximum absolute errors about 0.01031 for eight IDs and 0.007652 for 36 IDs). Reference-captured Gaussian inputs isolate arithmetic; seeded native Gaussian has separate repeatability evidence. Full context-sensitive text preparation, application playback and in-graph cancellation remain unfinished; the default native exact-length selector described below supports the baseline 8 and 36 IDs; additional lengths require explicit offline bundle export and separate evidence. This is experimental phoneme-to-WAV evidence, not arbitrary-text TTS or a certified accessibility session. Reproduce the two-length asset-backed replay with CKE_TTS_RUN_TWO_LENGTH_WAVEFORM=1 python3 -m unittest tests.test_v8_kokoro_waveform_two_lengths; without the asset-backed switch, standard nightly runs the circuit-authoring check and reports the full replay as SKIP. When run, the standard numerical-case inventory records execution PASS separately from the known connected waveform numerical FAIL; the pinned voice-bank check is a separate asset-backed case.

Checked runtime token-length header proof: one capacity-36 generated entry now validates a request-owned token count and runs the Kokoro embedding and input projection for valid 8 → 36 → 8 prefixes. The two outputs match the committed pinned PyTorch 36-token capture over each valid prefix (worst absolute error 9.54e-7); unused capacity stays untouched, and zero/excess lengths, malformed IDs, and contradictory planned capacities fail before publishing output validity. This uses the existing checked extent provider and operation-local scalar bindings; the embedding map now declares the storage spans needed for planner validation. The eight-token comparison is a prefix of the 36-token capture, not a distinct eight-token full-model oracle. The complete encoder, duration/prosody path, and waveform deployment still use separately compiled exact token counts. Reproduce the bounded proof with python3 -m unittest tests.test_v8_kokoro_runtime_header; the suite is registered in standard nightly.

Checked runtime token-length first-layer proof: one capacity-36 generated entry now runs the complete first ALBERT layer for valid 2 → 8 → 36 → 8 token prefixes. A checked length producer feeds embedding, rowwise projections, attention, LayerNorm and GELU; a checked 768× extent producer feeds both residual additions through a distinct runtime-ABI map of the existing FP32 kernel. The 36-token result matches the pinned PyTorch 2.8 first-layer capture (maximum absolute error 2.86e-6). At eight tokens, the runtime entry exactly matches a separately compiled eight-token CKE graph; that is a compiler-stitching comparison, not an independent eight-token PyTorch oracle. Short-request output padding stays untouched, and zero/excess lengths or a malformed ID reject without publishing a completed output; execution recovers on the next valid request. This is first-layer coverage, not the complete twelve-invocation encoder or a variable-length waveform deployment. Reproduce with python3 -m unittest tests.test_v8_kokoro_runtime_albert_layer; the suite is in standard nightly.

Checked runtime token-length complete encoder proof: one capacity-64 circuit now carries a validated token count through embedding, all twelve shared-weight ALBERT invocations and the final 768→512 phoneme-feature projection. The same generated native entry executes valid 2 → 8 → 36 → 64 → 2 requests, compares the final features and every layer output with independent hash-pinned PyTorch 2.8 captures for each length, and leaves reserved output padding untouched. The worst final-feature maximum absolute error across these captures is 1.94e-5 under the established 3e-5 encoder bound. Invalid counts and IDs reject without publishing output lengths; the next valid request succeeds. This certifies a runtime-length phoneme encoder, not the duration/prosody, text/acoustic, generator, or waveform stages under one variable-length entry. The existing phoneme-to-WAV hosts still use separately compiled exact token counts. Reproduce the encoder with python3 -m unittest tests.test_v8_kokoro_runtime_encoder; it is registered in standard nightly.

Checked runtime token-length duration proof: one capacity-64 generated entry now carries the validated token count through the complete phoneme encoder and duration predictor. It executes 2 → 8 → 36 → 64 → 2 token requests in one loaded library and caller-owned arena, leaving unused logits and durations untouched. For 36 tokens, independent pinned PyTorch 2.8 duration logits differ by at most 3.63e-5 under the existing 5e-5 duration checkpoint bound; all 36 integer durations and the 103-frame extent match exactly. Other lengths have execution, padding and repeatability evidence but no independent duration oracle yet. Invalid lengths reject before publishing any of the token, residual or frame extents, and a subsequent request succeeds. The selected duration provider map now validates declared logits and duration capacities against planned storage. The voice/style vector remains pinned to the 36-token fixture in this test, and duration expansion, prosody, waveform and deployment are still on exact-length graphs. Reproduce with python3 -m unittest tests.test_v8_kokoro_runtime_duration; this suite runs in standard nightly.

Checked runtime token-length acoustic text and expansion proof: one capacity-64 generated entry now computes the complete phoneme encoder, duration predictor, real acoustic text embedding/three convolution blocks/BiLSTM, and both duration-feature and acoustic-text expansions. Its checked token count reaches every row/frame consumer; the predicted checked frame count reaches both expansions. The caller-owned arena reserves 64 tokens and at most 3,200 frames, while valid extents and physical strides remain separate. Native 2 → 8 → 36 → 64 → 2 requests pass with untouched padding and exact repeated short output. At 36 tokens, direct pinned PyTorch 2.8 text checkpoints pass through the final 103-frame expansion: maximum text-expanded error 2.45e-6 under 3e-6. The duration stream differs by at most 6.62e-6 from an independent repeat of pinned predictor features under its 3e-5 bound. Invalid lengths, insufficient arena and failed predictor style stop before either expanded output is published, and a subsequent request succeeds. Other token lengths have execution and safety evidence but no independent text/prosody oracle here. The style vector is still the pinned 36-token selection, and downstream prosody, generator and WAV deployment remain exact-length graphs. Reproduce with python3 -m unittest tests.test_v8_kokoro_runtime_text_expansion; this suite is in standard nightly.

Checked runtime-length shared prosody proof: one capacity-64 generated entry now joins CKE-produced duration and acoustic-text streams to the shared prosody bidirectional LSTM. The checked frame extent drives both expansion and the transpose/scan calls, with capacity for at most 3,200 frames. One loaded library and caller-owned arena execute 2 → 8 → 36 → 64 → 2 token requests; the 36-token, 103-frame scan differs from the pinned PyTorch 2.8 capture by at most 4.56e-6 under its existing 1e-5 checkpoint limit. Other lengths have execution, padding and repeatability evidence only. Invalid requests and failed producers stop before publishing lengths or writing scan outputs; a later valid request succeeds. This is still a prefix circuit: the dynamic F0/noise branches, decoder, generator and waveform are unconnected, and the deployable WAV hosts still use exact-length graphs. Reproduce with python3 -m unittest tests.test_v8_kokoro_runtime_prosody_shared; this suite is registered in standard nightly.

Checked runtime-length F0/noise entry proof: the capacity-64 generated entry now carries CKE-produced shared prosody features into the channel-major transpose, separate style projections, and first AdaIN operation of each F0 and noise branch. The checked frame extent drives the transpose and both AdaIN calls; the planner reserves at most 3,200 frames, with valid data separate from physical strides and padding. One loaded library executes 2 → 8 → 36 → 64 → 2 phoneme-ID requests. For the 36-token, 103-frame request, F0 and noise first-AdaIN outputs differ from the committed operation-level PyTorch captures by at most 1.86e-5 and 1.69e-5 respectively under their 5e-5 checkpoint bounds. Other lengths have execution, padding and repeatability evidence only. Upstream and branch-local failures stop dependent calls and preserve unwritten branch outputs; later valid requests recover. This earlier test covers only the first normalization prefix; the complete runtime F0/noise evidence is summarized above. It is not a variable-length WAV path. Reproduce with python3 -m unittest tests.test_v8_kokoro_runtime_prosody_norm; the suite is registered in standard nightly.

Listening to the short diagnostic WAV: set CKE_TTS_RETAIN_DIR=/path/to/output alongside CKE_TTS_RUN_TWO_LENGTH_WAVEFORM=1. The asset-backed test retains captured-noise and seeded-noise eight-ID WAVs under kokoro-two-length-short/, with a reproduction report and hashes. Both are experimental generated speech; listening does not turn the failing connected PyTorch comparison into a PASS.

Exact-length native request preview: CKTTS003 extends the diagnostic package with checked phoneme-ID and style-buffer offsets. The native host accepts decimal phoneme IDs, a seed, and a CKVOICE1 bank exported from the hash-pinned af_heart.pt source. It validates the request count against the token count compiled into that host, selects row count − 3, copies the two 128-value style slices, generates request-owned noise, and calls the generated entry. The asset-backed eight-ID test compares its WAV with the same-seed generated result. The initial package was assembled by fixture tooling; the offline pinned-BUMP exporter described below now assembles the static package without fixture tensors. Each host is still tied to one exact-length graph. The selector described below dispatches only certified 8-ID and 36-ID requests; full context-sensitive text preparation and a persistent-weight speech session remain unfinished; the process-level stop/replace supervisor is described below. The exporter requires PyTorch only when creating the bank, not when running the native host.

Pinned-BUMP native request build: version/v8/tts/build_kokoro_request_runtime.py derives compiler weight metadata from the hash-pinned BUMP and declarative binding catalog, builds the canonical waveform circuit through normal v8 lowering and codegen, compiles the generated library and C host, and invokes export_kokoro_request_package.py for the static CKTTS003 package. No test fixture supplies weights or model stages to this build. The package verifies all 580 selected FP32 weights, including 24 forward/reverse recurrent concatenations, and contains three pinned STFT constant segments. Build one exact-length runtime with python3 version/v8/tts/build_kokoro_request_runtime.py --bump-dir /path/to/pinned-bump --tokens 8 --output-dir /path/to/empty-build; the resulting native host still requires a pinned CKVOICE1 bank, phoneme-ID CSV and seed. The asset-backed eight-ID and 36-ID replays check the 32,400- and 61,800-sample WAV hashes (8f88a076382944cfd26826d964cf12f378ebc8c16f7ce98ea5ed24e98667eda1 and 187e777636f7071776968bb7a7c4ced52f3d0438bedc281b84416562c844015e). This still requires one build per supported exact phoneme count. The selector and bounded text frontend/session described below build on these exact-length hosts; they do not provide arbitrary-length G2P or in-graph cancellation. Matching diagnostic WAV hashes does not resolve the connected PyTorch waveform numerical failure. Cheap manifest and package bounds tests run in standard nightly; the full-model replay requires CKE_TTS_RUN_REQUEST_PACKAGE_FULL=1, the pinned BUMP directory and native voice bank.

Native exact-length bundle and selector: version/v8/tts/build_kokoro_dispatch_bundle.py builds both pinned request runtimes and copies the hash-pinned af_heart CKVOICE1 bank into one relocatable bundle. The C selector native-kokoro-dispatch accepts a bundle directory, output WAV path, seed and phoneme-ID CSV. It rejects counts other than 8 or 36 before opening model artifacts, verifies the selected host, generated library, request package and voice-bank SHA-256 hashes, then executes the exact-length host. That host resolves the generated-entry symbol with dladdr and verifies the on-disk library artifact hash before synthesis. The symbol path and file hash identify capture-time provenance; they are not an embedded build identity or proof against concurrent file replacement. Build with python3 version/v8/tts/build_kokoro_dispatch_bundle.py --bump-dir /path/to/pinned-bump --voice-bank /path/to/af_heart.ckvoice --output-dir /path/to/empty-bundle, then run /path/to/bundle/native-kokoro-dispatch /path/to/bundle output.wav 7 0,...,0 with exactly 8 or 36 decimal IDs. The bundle builder publishes only after both exact-length runtimes and the selector build successfully; failed builds leave the destination absent or empty. The selector rejects any pre-existing WAV destination, including symlinks and hard links to bundle assets, before invoking a host; the host also creates output exclusively to close the check-to-write race. Choose a fresh output filename for each request. The export requires OpenSSL libcrypto for hashing; the deployed selector and host do not need Python. This is exact-length phoneme-to-WAV execution; only the retained 8-ID and 36-ID utterances have WAV-hash evidence. Other ID sequences have input bounds checks but no independent model-level parity certification. It is not arbitrary text, a persistent session, or PyTorch waveform parity. Cheap rejection and identity tests run in standard nightly; full asset-backed WAV replay remains opt-in.

Explicit AVX2/FMA native bundle: the offline Kokoro request and two-bucket builders now accept --conv-provider avx2_fma; scalar remains the default. Kokoro circuit authoring explicitly selects the already mapped serial x86 AVX2/FMA providers for 88 Conv1D calls, records the selected numerical contract, and lets normal lowering/codegen build the native hosts. The generated provider checks AVX2/FMA at runtime and rejects unsupported CPUs. On the i7-14700T, one standalone dispatch run took 7.595 seconds for 32,400 samples and 15.078 seconds for 61,800 samples; both WAV SHA-256 hashes exactly matched the scalar seeded baselines. These single-run process timings include loading and writing and are not a repeatable speedup estimate. The option does not change the known connected PyTorch waveform parity failure, and both utterances remain slower than real-time playback. Use python3 version/v8/tts/build_kokoro_dispatch_bundle.py --bump-dir /path/to/pinned-bump --voice-bank /path/to/pinned/af_heart.ckvoice --conv-provider avx2_fma --output-dir /path/to/empty/bundle; the asset-backed two-WAV check selects the same path with CKE_TTS_CONV_PROVIDER=avx2_fma.

Native dictionary-only text preview: build_kokoro_lexicon_frontend.py exports a hash-pinned Misaki US gold dictionary and Kokoro vocabulary to a checked CKLEX1 sidecar and compiles native-kokoro-text. At deployment, the C frontend accepts text, verifies the sidecar hash, converts supported ASCII words and basic punctuation into phoneme IDs, and invokes the native 8/36-ID selector; Python is not required for this request path. With the pinned bundle and seed 7, “Hello.” and “Read this assistant response aloud.” reproduce the retained 32,400- and 61,800-sample WAV hashes. Export with python3 version/v8/tts/build_kokoro_lexicon_frontend.py --config /path/to/pinned/config.json --misaki-us-gold /path/to/pinned/us_gold.json --output-dir /path/to/empty/frontend, then run native-kokoro-text bundle-dir us-gold.cklex output.wav 7 'Hello.'. At this earlier milestone the frontend used dictionary default pronunciations, rejected numeric forms and unknown terms, and the selector accepted only 8 or 36 IDs. Current bounded cardinal and runtime-length behavior is described above. This is a bounded text-to-WAV preview, not arbitrary assistant-response speech, numerical waveform parity, playback or cancellation. Cheap ID and rejection tests run in standard nightly; full generated WAV replay requires pinned assets and CKE_TTS_RUN_TEXT_FULL=1.

Optional third exact-length bucket: the bundle exporter retains 8 and 36 IDs by default and accepts up to four explicit --experimental-count values (12 in this fixture) to compile a separate 12-ID circuit, package and native host at export time. The generated selector validates artifact hashes and routes by the actual phoneme count; it does not compile per request or pad one graph to another length. With the pinned dictionary frontend, “Hello there.” produced 12 IDs and a 36,000-sample, 24 kHz mono WAV through generated C. An asset-backed single-session 8 → 12 → 8 replay matched the retained CKE seeded hashes, while the new 12-ID direct pinned-PyTorch waveform parity is explicitly NOT_TESTED. This widens the experimental text-to-WAV trial, not arbitrary-length or full Misaki G2P support. Reproduce the bundle with python3 version/v8/tts/build_kokoro_dispatch_bundle.py --bump-dir BUMP --voice-bank af_heart.ckvoice --output-dir BUNDLE --conv-provider avx2_fma --experimental-count 12; asset-backed session replay uses CKE_TTS_RUN_THIRD_LENGTH_FULL=1 CKE_TTS_THIRD_LENGTH_BUNDLE_DIR=BUNDLE CKE_TTS_TEXT_FRONTEND=FRONTEND/native-kokoro-text CKE_TTS_TEXT_LEXICON=FRONTEND/us-gold.cklex python3 scripts/nightly_runner.py --tests tts_kokoro_native_speech_session.

Native one-request speech supervisor: the exported frontend now also builds native-kokoro-session. Run native-kokoro-session native-kokoro-text bundle-dir us-gold.cklex output-root [player|-] and send newline-terminated commands SPEAK<tab>seed<tab>text, STOP, or QUIT on standard input, keeping the pipe open until the request finishes or is cancelled. It reports READY and request-ID-tagged STARTED, WAV_READY, PLAYING, COMPLETED, CANCELLED, or ERROR events on standard output. There is one active request and no pending queue: a new SPEAK kills and replaces synthesis or the optional player, removes any cancelled WAV, then starts a fresh native child. The child calls the existing generated Kokoro host; the supervisor does no neural arithmetic. Before WAV_READY or playback, the supervisor verifies the generated file is a complete canonical RIFF/WAVE containing nonempty 24 kHz mono PCM16 data; invalid output raises ERROR and is removed. The optional player is an external executable receiving the complete WAV path as its sole argument. This is whole-utterance playback and process-level interruption, not streaming model inference or bounded cancellation inside generated operations. Each request reloads the model, so this is not a persistent-weight performance claim. Cheap process and fake-player controls run in standard nightly; a pinned-bundle cancel-then-Hello replay is asset-backed. Full text/G2P, more lengths, application queue policy, listening quality and P3/Ryzen cancellation/latency remain open.

Persistent native waveform worker: the hash-checking runtime dispatcher accepts native-kokoro-dispatch bundle-dir --session and then starts the bounded WAV host. It validates and loads the package once, then accepts RUN<tab>output.wav<tab>seed<tab>phoneme-ids-csv and QUIT on standard input. Each RUN rebinds checked IDs, request length, selected voice row and request seed before the same generated entry executes; only a successfully validated WAV emits WAV_READY<tab>samples<tab>path. A synthetic generated-entry test removes the package after READY, then proves 8→13→36→8 replay, a rejected request and successful recovery. An asset-backed local run of the first two full-summary chunks and a repeat of the first used one loaded 64-token-capacity library and produced 50,400, 45,600 and 50,400 samples; the repeated first WAV hash matched exactly. The worker does not yet perform full-text planning or playback. It is synchronous during each generated call; stop/replacement currently requires a supervising process to kill and restart it, so this does not certify persistent weights across cancellation. The separate text supervisor above still reloads for each request until it is connected to this worker. Connected waveform numerical parity remains FAIL.

Seeded request replay: an asset-backed test runs the complete generated entry three times in one process and one arena with native Gaussian seeds 7, 8 and 7. It uses two distinct 36-phoneme af_heart utterances, with checked frame counts 103, 98 and 103. Between the first and second valid requests, a position-zero invalid phoneme ID must fail without publishing a valid length or changing the waveform buffer. The later B request executes with valid length, finite audio and preserved padding, while the first and final A FP32 waveforms match exactly. B is not compared with an independent clean-arena baseline. This is early-rejection recovery, not recovery after partial graph execution. Run CKE_TTS_RUN_SEEDED_REPLAY=1 python3 -m unittest tests.test_v8_kokoro_generated_waveform.KokoroGeneratedWaveformTest.test_seeded_native_noise_reuses_one_generated_entry. That seeded same-length replay does not test different phoneme counts or voice rows; the two-bucket diagnostic above does. Text preparation and cancellation remain untested.

Ryzen diagnostic measurement (2026-10-12): the standalone seeded host produced 61,800 samples, or 2.575 seconds at 24 kHz, in 94.473 seconds of process wall time on an AMD Ryzen 9 9950X3D. Its WAV hash matched the earlier Intel run exactly (187e777636f7071776968bb7a7c4ced52f3d0438bedc281b84416562c844015e). A controlled repeat with explicit single-thread environment took 78.365 seconds with the same WAV hash. Both timings include package loading and WAV writing; OS cache and clock effects were not isolated, and neither measures warm execution or time to first playable audio separately. A 99 Hz perf sample attributed 54.05% of samples to the checked Conv1D implementation, 28.69% to libm __fmaf_fma3, and 12.63% to the generated library's fmaf linkage stub. This single-threaded scalar build is far slower than real-time playback. An experimental whole-library -mfma rebuild took 49.199 seconds, but changed 26,579 PCM samples (worst difference 192 PCM steps). With captured reference Gaussian instead, the FMA rebuild still differed from the pinned FP32 waveform by 0.006864 maximum. A narrower experiment compiled only src/kernels/audio_conv1d_checked.c with -mfma, leaving other generated-library sources at -O2 -ffp-contract=off: its first Ryzen process took 51.457 seconds and a controlled repeat took 52.199 seconds, both producing the exact baseline WAV hash. The whole-library FMA controlled repeat took 49.167 seconds and again changed the WAV hash. In identical-input full-graph replay, seven retained checkpoints, including F0, source STFT channels, source convolution and final FP32 waveform, matched elementwise exactly. These are promising measurements for a separately mapped Conv1D implementation, not an accepted portable optimization: production selection still requires a declared CPU/build contract, independent oracle and bounds tests, and standard-nightly registration. The machine-readable Ryzen experiment manifest records the build commands, source and artifact hashes, CPU settings, measured runs and profiling method.

Explicit Conv1D hardware-FMA candidate: CKE now has separately mapped checked FP32 Conv1D providers for x86 hardware FMA, with a runtime CPU guard and the same ordered fmaf numerical semantics as the scalar provider. The default scalar selection remains intact. Pinned PyTorch fixtures, exact scalar-versus-candidate comparisons, rejected-output preservation, and normal generated-call composition pass in standard nightly. In an asset-backed complete generated entry, selecting the candidate for 88 convolutions left six checked intermediates and all 61,800 FP32 waveform samples exactly equal to the scalar run. On a Ryzen 9 9950X3D pinned to CPU 0 or 16, the candidate kernel was approximately 1.58 times faster for the tested 512×512×36 and 128×22×12000 shapes; those are kernel timings. An alternating two-run replay of the complete generated entry on Ryzen CPU 0 measured warm scalar execution at 100.892 seconds and the selected hardware-FMA entry at 53.155 seconds, a 1.90× speedup with identical 61,800-sample FP32 output. This excludes asset loading, arena preparation, WAV writing and playback, and uses captured Gaussian diagnostic input. The candidate still takes about 20.6 wall-clock seconds per generated audio second. The connected waveform still fails the pinned-model numerical comparison, so practical speech speed and quality remain unproven. Reproduce the kernel measurements with taskset -c 0 python3 scripts/benchmark_audio_conv_hwfma.py --repeats 5 and the optional full graph comparison with CKE_TTS_RUN_HW_FMA_REPLAY=1 python3 -m unittest tests.test_v8_kokoro_generated_waveform.KokoroGeneratedWaveformTest.test_full_waveform_hardware_fma_provider_replay. The evidence manifest records individual samples, compiler settings, identities, and limits.

Explicit AVX2/FMA Conv1D candidate (2026-10-12): A separately mapped FP32 provider computes eight independent output frames per vector while preserving each frame’s input-channel/tap FMA reduction order. The scalar provider remains the default. The ordinary and dilated providers pass pinned PyTorch fixtures and exact ordered-FMA replay, including padded strides, tails, capacity rejection and recovery. Selecting them for 88 calls in the complete generated graph left six checked intermediates and all 61,800 FP32 waveform samples exactly equal to the scalar diagnostic run. On the local Intel Core i7-14700T, five measured warm generated-entry runs after one warmup per provider gave a 106.87-second scalar median and 14.23-second AVX2 median (7.51×), with respective ranges of 106.85–106.92 and 14.20–14.23 seconds. The runs were pinned to CPU 2 and produced the same 2.575-second output. On Ryzen 9 9950X3D, five measured alternating standalone seeded process runs after one warmup per provider gave a 53.67-second median for hardware FMA and 11.63 seconds for AVX2 (4.61×); the ranges were 53.62–56.05 and 11.63–11.65 seconds. Runs were pinned to CPU 0 and every WAV hash agreed. These process timings include package loading and WAV writing, so they are distinct from the Intel warm-entry timings. A capture from the running Ryzen synthesis process records the mapped generated library path and its on-disk hash; this is stronger than an ldd lookup, though it is not an embedded runtime build identity. The Ryzen profile now attributes 52.63% of sampled self cycles to AVX2 Conv1D, 18.28% to checked linear rows and 9.90% to dense transposed convolution. The evidence manifest records artifact hashes, commands and limits. This remains one fixed-phoneme, one-voice diagnostic path: connected PyTorch waveform parity, arbitrary text, listening and accessibility-session latency are not certified. AVX-512F and VNNI have not been benchmarked in this selection.

Explicit-pool parallel Conv1D candidate (2026-10-12): The optional x86 AVX2/FMA provider partitions independent output channels through a caller-owned CKE thread pool. The map declares pool, worker count, scratch and numerical contract; default selection remains unchanged. Pinned PyTorch dilated cases, ordinary stride-two convolution, padded layouts, rejection/recovery, distinguishable concurrent requests and a normal generated circuit pass in standard nightly. The generated test queries the compiled library’s AVX2/FMA probe, so an unexpected unsupported result on capable hardware fails. A same-run comparison on an Intel Core i7-14700T pinned to physical cores 0, 2, 4 and 6 used one warmup and five alternating measured runs per variant. Median warm entry times were 14.283 seconds for serial AVX2, 14.261 seconds with one worker, 10.079 seconds with two, and 7.880 seconds with four. Four workers improve the serial AVX2 entry by 1.81× and still require about 3.06 seconds of synthesis per audio second. All six compared intermediates and 61,800 FP32 waveform samples matched serial AVX2 exactly. The final measurement record contains the tested source revision, generated-library hashes, loaded-mapping check, compiler command, affinity, host load and individual samples. The earlier scalar comparison remains historical evidence. Both measurements use one fixed diagnostic utterance with prepared weights and captured Gaussian input; they exclude loading, text preparation, WAV writing and playback. Connected PyTorch waveform parity, practical speech latency and performance on other CPUs remain unproven.

Numerical diagnosis: the standalone encoder fixture forces PyTorch 2.8 eager attention, while the pinned full KModel uses SDPA by default. Their final encoder features differ by at most 1.49e-5 for the fixed 36-token input. A direct full-model F0 capture now includes the shared-scan input and inner F0 modules. Connected CKE shared-scan input differs from that direct input by 1.27e-5; replaying the shared scan and first AdaIN with identical CKE inputs in pinned PyTorch differs from the native outputs by 2.01e-6 and 1.43e-6, respectively. The connected first AdaIN differs from the direct full-model hook by 1.86e-5. This localizes an upstream contribution; it does not certify the remaining connected waveform. A diagnostic full-model eager run changes its FP32 waveform from the default SDPA run by up to 0.005744, but neither attention mode brings the CKE WAV into full numerical parity. Keep the two reference dispatch identities separate; do not refresh either fixture or widen a global tolerance to conceal the difference.

First-layer attribution: direct hooks from the pinned full KModel show its first embedding and input projection agree with the generated CKE entry within 2.38e-7 and 9.54e-7. The first Q/K/V projections differ by up to 3.34e-6, 2.86e-6 and 2.86e-6, before attention score reduction. Pinned PyTorch 2.8 replays on the identical CKE projection input attribute up to 2.38e-6, 2.86e-6 and 1.55e-6 to the local linear reduction, with the remainder affected by upstream input drift. The first attention context differs by 7.78e-6 in the connected entry; the eager-versus-SDPA full-model reference difference at that same context is 2.13e-6. These are distinct numerical contributions. Do not change the existing FP64 linear or attention provider solely to fit one reference dispatch; a new reduction order needs a separate provider and map.

Reproduce the retained direct-hook comparison with python3 -m unittest tests.test_v8_kokoro_generated_prosody_complete.KokoroGeneratedProsodyCompleteTest.test_direct_full_model_f0_inner_checkpoints_localize_drift. The live identical-input scan/AdaIN replay additionally requires pinned PyTorch 2.8.0+cpu; other versions report SKIP. Regenerate the direct-hook fixture only from the pinned assets and code using capture_kokoro_v1.py --capture-f0-fine followed by build_prosody_f0_fine_fixture.py --capture-dir. The capture keeps the default SDPA full-model dispatch and its original waveform hash.

Reproduce the first-layer comparison with python3 -m unittest tests.test_v8_kokoro_generated_encoder.KokoroGeneratedEncoderTest.test_first_layer_against_direct_full_model_sdpa_hooks. Pinned PyTorch 2.8.0+cpu is required for the separate same-input Q/K/V replay; other versions report SKIP. Regenerate the first-layer capture using capture_kokoro_v1.py --capture-bert-fine followed by build_kokoro_bert_fine_fixture.py --capture-dir. The default SDPA full-model waveform hash must remain unchanged.

Source/STFT numerical diagnosis

The connected generated source path still fails direct pinned-model parity. A diagnostic variant of the scalar STFT records the actual FP64 real and imaginary accumulators immediately before atan2; it uses caller-owned trace storage and the same arithmetic as the production provider. With identical pinned source samples, the first-frame bin 7 has CKE real -0.06778858773229121 and imaginary -1.8178155721687052e-9, yielding -π. Pinned PyTorch 2.8 reports real -0.06778859347105026 and positive-zero imaginary, yielding +π. A 20-sample excerpt reproduces this exact CKE accumulator. Raw phase is fed to source convolution, so circular-angle equivalence is insufficient: identical source samples produce a first-convolution maximum difference of 0.160075 despite complex STFT errors below 1.6e-7. Feeding identical reference STFT channels to the native convolution reduces its maximum difference to 3.34e-6.

There is also an upstream source difference. The earlier difference-interpolation graph differed from the pinned source by at most 6.10e-4; PyTorch STFT on that CKE waveform still left a 0.333573 first-convolution maximum difference versus the pinned full model. With the weighted-FMA provider selected, those bounds improve to 4.28e-4 and 0.260741 on the same fixture. A controlled pinned-model run that replaces only its F0 input with CKE's generated F0 reproduces a 0.260744 first-convolution difference and a 0.007766 final reference-waveform difference. CKE's source waveform and the pinned source module agree within 1.49e-8 when given that same generated F0 and captured noise. The connected numerical result remains FAIL. These substitutions diagnose causes; they are never part of the generated production graph.

A pinned-model waveform-impact diagnostic replays the exact captured random tensors and verifies its unmodified baseline is bitwise equal to the retained 61,800-sample waveform. It then substitutes alternative first source-convolution outputs in the Python reference only. With pinned source plus CKE STFT/convolution, the final waveform changes by at most 2.31e-4 (RMSE 8.55e-6). With the weighted-FMA source and PyTorch STFT/native convolution, it changes by at most 0.007667 (RMSE 2.32e-4), down from 0.013611 (RMSE 8.46e-4) for the earlier source provider. With the new generated source held fixed, switching PyTorch to CKE STFT changes the downstream waveform by at most 1.28e-6; the pinned-source phase branch cut remains a separate failing compatibility case. These are controlled reference-model interventions, not a CKE-generated waveform. The present contract keeps the scalar direct-DFT provider and the raw-phase compatibility failure visible. A backend-matching STFT reduction-order provider requires a separate map and independent tests; no phase snapping, oracle substitution in production, or global tolerance change is justified by this diagnostic.

The F0 error decomposition identifies the upstream target: separate standard-nightly diagnostic cases report full-model maximum differences of 3.52e-6 after the first F0 block, 1.91e-5 after the second, 2.38e-5 after the third, and 3.24e-4 after final projection. These are connected checkpoints, not identical-input operation replays; they do not yet identify the first divergent operation. Applying the same FP64 projection to both third-block outputs produces up to 3.28e-4 difference. Native and pinned projections also each differ from the FP64 projection on their respective identical inputs, by at most 1.71e-4 and 1.64e-4. Across the pinned and generated-F0 source waveforms, 30 raw STFT phase values cross the ±π branch cut. Even the two source waveforms that agree within 1.49e-8 under identical generated F0 produce one branch-cut difference at bin 7, frame 0. The next numerical work should replay the first F0 block and then its downstream operations with identical inputs, preserving each provider's reduction contract. The phase-sensitive consumer needs its own explicit compatibility decision backed by waveform evidence.

Oracle reproduction is a separate gate: on the 2026-10-21 Intel i7-14700T host, the retained pinned PyTorch capture and a fresh run of the same model differ by up to 0.005744 at the waveform, while captured F0, source and first source convolution reproduce exactly. This is an oracle reproducibility FAIL for that host and dispatch; it is not evidence that the CKE waveform passes or fails a native comparison. The source-impact diagnostic now reports every baseline checkpoint and controlled intervention before returning failure, so a drifting reference cannot hide the F0/source/STFT attribution. With generated F0 substituted only inside the labeled reference diagnostic, the live reference waveform changes by up to 0.007766. Holding generated source fixed and switching its STFT implementation changes the downstream waveform by up to 1.28e-6; the raw-phase branch-cut compatibility failure remains distinct. The standard nightly registers the cheap report test; asset-backed live execution is explicit and reports NOT_TESTED when unavailable. Run it with CKE_TTS_RUN_SOURCE_IMPACT_FULL=1 CKE_TTS_SOURCE_IMPACT_MODEL_DIR=/path/to/pinned/kokoro CKE_TTS_SOURCE_IMPACT_CAPTURE_DIR=/path/to/pinned/capture python3 -m unittest tests.test_v8_kokoro_source_impact_diagnostic. These interventions do not enter the production graph, whose connected numerical parity remains FAIL.

python3 -m unittest tests.test_v8_audio_stft_mag_phase_oracle tests.test_v8_kokoro_generated_source_stft_conv -v
python3 -m tests.diagnose_kokoro_source_waveform --model-dir /path/to/pinned/kokoro --capture-dir /path/to/pinned/capture

The first generator join is reproduced with python3 version/v8/tts/build_kokoro_generator_stage0_join_circuit.py --check and python3 -m unittest tests.test_v8_kokoro_generator_stage0_join. The test reports the direct-model numerical mismatch separately from successful generated execution and never substitutes a reference intermediate into the connected graph. Its captured Gaussian input remains a diagnostic fixture.

The first main generator block is reproduced with python3 version/v8/tts/build_kokoro_generator_main_resblock0_circuit.py --check, python3 version/v8/tts/build_kokoro_generator_main_resblock0_oracle_circuit.py --check and python3 -m unittest tests.test_v8_kokoro_generator_main_resblock0. The direct-input diagnostic certifies this block's arithmetic against nine pinned full-model checkpoints, including selected-provider X-Ray comparison. The connected generated entry consumes CKE's own join and reports the inherited numerical FAIL separately; it never uses the diagnostic input. Standard nightly runs the suite; its fixture can be rebuilt from the pinned model capture and effective-weight BUMP bundle.

The complete first-stage residual pool is reproduced with python3 version/v8/tts/build_kokoro_generator_stage0_pool_circuit.py --check, python3 version/v8/tts/build_kokoro_generator_stage0_pool_oracle_circuit.py --check and python3 -m unittest tests.test_v8_kokoro_generator_stage0_pool. The direct-input entry supplies the pinned join only to isolate block arithmetic and the three-way mean. The connected entry supplies its own join and retains a separate numerical FAIL. The committed fixture comes from the pinned full-model capture and effective-weight BUMP bundle; altered-length requests are safety evidence only.

The second main-path ingress is reproduced with python3 version/v8/tts/build_kokoro_generator_stage1_ingress_circuit.py --check, python3 version/v8/tts/build_kokoro_generator_stage1_ingress_oracle_circuit.py --check and python3 -m unittest tests.test_v8_kokoro_generator_stage1_ingress. Its direct-input test isolates the new arithmetic from the known upstream mismatch; the connected test executes CKE's own preceding stages. The pinned fixture is regenerated by version/v8/tts/reference/build_kokoro_generator_stage1_ingress_fixture.py from full-model hooks and effective BUMP weights. This boundary produces 128-channel generator features, not audio samples.

The second source convolution is reproduced with python3 version/v8/tts/build_kokoro_generator_stage1_source_conv_circuit.py --check, python3 version/v8/tts/build_kokoro_generator_stage1_source_conv_oracle_circuit.py --check and python3 -m unittest tests.test_v8_kokoro_generator_stage1_source_conv. It applies pinned effective 22→128, kernel-one weights to the generated source STFT at the checked 12,361-frame extent. A separate diagnostic entry feeds the exact pinned STFT channels and differs from the full-model source-convolution hook by at most 4.77e-7. The connected entry consumes CKE's own upstream STFT and still differs by 0.263449; that numerical result remains a diagnostic FAIL, not a model-parity pass.

The second-stage pool gate is python3 -m unittest tests.test_v8_kokoro_generator_stage1_pool. The complete diagnostic waveform gate is python3 -m unittest tests.test_v8_audio_spectral_head_oracle tests.test_v8_kokoro_istft_full_model tests.test_v8_kokoro_generated_waveform. Regenerate its circuits with python3 version/v8/tts/build_kokoro_waveform_circuit.py --check and python3 version/v8/tts/build_kokoro_waveform_oracle_circuit.py --check. The direct-input entry isolates the final convolution and inverse STFT; the connected entry computes every upstream tensor itself. Its model-level numerical comparison remains a FAIL, and the WAV is experimental. Set CKE_TTS_RUN_STANDALONE=1 to run the heavier standalone C-host replay on an asset-backed machine; CKE_TTS_RETAIN_DIR retains its native binary, generated library, prepared fixed-input package and WAV outside the checkout.

Controlled source-path isolation: python3 -m unittest tests.test_v8_kokoro_generated_source_stft_conv feeds the pinned STFT channels directly to the native source-convolution kernel. Its maximum error against the direct full-model convolution hook is 3.34e-6, so the checked convolution contract passes with identical input. With the exact pinned source waveform, native STFT magnitude differs from pinned PyTorch 2.8 by at most 1.20e-7, but one raw phase sign differs at bin 7/frame 0 and changes the first convolution by 0.1601. A caller-owned diagnostic trace records the actual pre-atan2 real and imaginary accumulators. With the weighted-FMA provider selected, generated-source-to-pinned-source drift still propagates through PyTorch STFT to a 0.260741 first-convolution maximum difference. Raw-phase compatibility remains a numerical FAIL. The live comparison requires pinned PyTorch 2.8 and is explicitly skipped in other environments; the committed-fixture convolution comparison remains available without PyTorch. No reference tensor is substituted into the production generated graph.

Native excitation RNG boundary: the graph receives explicit Gaussian samples and publishes no RNG state. The standalone C host now supports a separate diagnostic package that fills the reserved Gaussian buffer with the checked counter-based provider using a request seed before invoking the same generated entry. This tests deterministic native execution without a global RNG; it does not make PyTorch and CKE random draws equal, nor does it establish connected waveform parity or a cancellable multi-request session. The captured-Gaussian package remains the identical-input arithmetic lane.

Input geometry limit: the three direct-model decoder comparisons all use 36 phoneme IDs, the same af_heart conditioning selection, and one compiled graph. Their distinct A=98, 101 and 103 frame counts exercise runtime frame extents; they do not establish variable phoneme lengths or different voice rows. Before a reusable speech service is claimed, certify those inputs, capacity boundaries and repeat-after-failure behavior. The connected source graph produces excitation samples, not final waveform samples or playable audio.

Decoder numerical contract: kokoro.decoder-complete.pinned-fp32-v1 assigns one ceiling to each named checkpoint across all three utterances. The final block's second AdaIN output differs by up to 8.12e-5 on one alternate utterance; its following convolution differs by up to 1.20e-4, while the residual output differs by up to 8.41e-5. The 1e-4, 2e-4 and 1e-4 ceilings for those three stages reflect measured propagation through this connected FP32 graph. The larger convolution error does not establish an exact reduction-order cause. The test reports each checkpoint's worst index, native/reference values, maximum absolute error and RMSE, and rejects fixtures with different model, reference-code or source-asset identities.

The authoritative runnable gate for the acoustic text branch is python3 -m unittest tests.test_v8_kokoro_text_primitives tests.test_v8_checked_text_ops_generated tests.test_v8_kokoro_generated_text_encoder. The first suite tests reusable scalar arithmetic and rejection; the second compiles a model-neutral graph; the third lowers a 178-operation Kokoro circuit to one generated native entry with pinned effective weights. Repeated calls reset recurrent state; malformed convolution weights stop downstream execution without publishing an extent. The generated model output is still features, not speech.

The current connected prosody gate is python3 -m unittest tests.test_v8_audio_prosody_upsample_oracle tests.test_v8_runtime_extent_scale tests.test_v8_prosody_upsample_generated tests.test_v8_kokoro_generated_prosody_complete. The canonical complete builder is python3 version/v8/tts/build_kokoro_prosody_complete_circuit.py --check. It extends the earlier first-block circuit through a checked A-to-2A boundary, both remaining F0/noise residual blocks and their projections. The source-page status table is authoritative; earlier partial-prefix suites remain independent regressions.

The connected decoder-ingress gate is python3 -m unittest tests.test_v8_audio_concat_channels_checked tests.test_v8_audio_concat_channels_generated tests.test_v8_kokoro_generated_decoder_ingress. The circuit is regenerated by python3 version/v8/tts/build_kokoro_decoder_ingress_circuit.py --check. The two-input join provider copies valid channel-major FP32 samples exactly, validates all input regions before writes, and preserves physical padding. Effective decoder weights and direct model hooks come from the pinned Kokoro/PyTorch 2.8 capture; the generated entry computes every upstream tensor itself. The same 103-frame length binds all ingress consumers after checked 206-to-103 downsampling. X-Ray resolves the join's selected exact-copy contract and compares only the 103 valid frames of each 128-frame row, with artifact and resolved runtime-library provenance recorded separately. This is decoder-input evidence, not a generated acoustic decoder output or a WAV.

The connected first-decoder-block gate is python3 -m unittest tests.test_v8_kokoro_generated_decoder_encode, and its circuit regeneration check is python3 version/v8/tts/build_kokoro_decoder_encode_circuit.py --check. Effective weights come from the pinned BUMP export; direct hooks from the pinned full model supply the oracle. The circuit owns style and residual connections, maps provide checked provider contracts, and generated C executes with caller-owned buffers. The numerical comparison applies separate checkpoint bounds rather than one global decoder tolerance. X-Ray resolves the final residual provider's selected contract and compares only valid output frames with separate artifact and resolved-library provenance. Altered-duration requests prove checked geometry and padding only; they are not additional model-level oracle cases. This block produces acoustic features, not waveform samples.

The complete-decoder gate is python3 -m unittest tests.test_v8_kokoro_generated_decoder_complete; regenerate its circuit with python3 version/v8/tts/build_kokoro_decoder_complete_circuit.py --check. It reuses the same style-conditioned block authoring and existing checked providers. The pinned full-model capture and two additional same-geometry utterances provide direct output checkpoints. The generated entry performs every upstream model stage itself; Python captures and compares reference values but does not schedule native execution. The 512-by-2A output is ready for the waveform generator. This is phoneme-to-acoustic-feature evidence, not playable speech.

F0/noise arithmetic contract: audio_adain_instance_norm_f32 implements channelwise InstanceNorm1d affine followed by style affine over checked valid frames. audio_scaled_sum_strided_f32_checked scales the completed residual sum. The new nearest-upsample provider copies exact FP32 values; the depthwise transposed-convolution provider accumulates in ascending input-frame/tap FP32 FMA order and uses caller-owned scratch. A checked integer scale publishes 2A only after overflow and capacity checks. Independent PyTorch 2.8 fixtures cover the new upsampling primitives; direct pinned full-model hooks cover both complete branches. The F0 projection uses a checkpoint-specific 5e-4 absolute ceiling: its 256-channel reduction amplifies a measured 2.39e-5 third-block input difference. The noise projection and both residual-block checkpoints retain 1e-4 ceilings. These are inference-only contracts.

Text embedding boundary: audio_text_embedding_channel_major_f32 performs an exact checked FP32 table lookup with caller-owned output, explicit capacity and channel-major stride. Its pinned PyTorch 2.8 fixture and small generated synthetic circuit pass exact equality; invalid IDs, nonfinite selected weights, short buffers and overflow leave output unchanged. python3 -m unittest tests.test_v8_kokoro_generated_text_embedding compiles a 163-operation Kokoro circuit through normal lowering and generated C. Its embedding matches the independent pinned [512,36] capture bitwise; the 103-frame expanded embedding also matches a separately computed repeat of that capture bitwise. X-Ray records valid extents, physical strides, artifact hash and resolved runtime symbol library; its embedding checkpoint resolves the exact lookup contract. The expansion checkpoint now records the selected channel-major provider contract; this staging fixture remains a separate historical gate. The generated text expansion is a staging test: Kokoro applies convolution, normalization, activation and a bidirectional LSTM between embedding and duration expansion. That older fixture's values are not Kokoro's final text features; use the complete acoustic text encoder suite above for the current generated feature evidence. Neither circuit generates waveform samples.

Connected expansion evidence: python3 -m unittest tests.test_v8_kokoro_generated_expansion compiles the 162-operation circuit through normal v8 lowering and codegen. For the pinned 36-token, 103-frame capture, generated duration expansion differs from the independent PyTorch reference by at most 1.28e-5 locally; the oracle-fed text expansion is bitwise equal. The test checks valid regions, untouched padding, repeated execution, rejected upstream results, and X-Ray artifact and resolved-symbol provenance. X-Ray now records each expansion checkpoint’s selected provider contract, including the distinct token-major and channel-major implementations, when its selected map has one unambiguous validated capability. These are feature tensors, not generated waveform samples.

Metadata limit: the fixed circuit declares matching channel dimensions, and the compiler checks overridden capacities, token count and physical strides. A deliberately edited circuit can still give a dimension-bound channels scalar that differs from the map's logical C. General dimension-to-shape consistency remains a compiler-contract follow-up before accepting arbitrary authored expansion circuits.

The status table above is authoritative. The milestone records and initial operation inventory below describe earlier bring-up states; their pending-work statements are historical unless repeated in the current table.

python3 version/v8/tts/build_kokoro_duration_circuit.py --check
python3 -m unittest tests.test_v8_feature_concat_broadcast_oracle tests.test_v8_feature_concat_broadcast_generated tests.test_v8_kokoro_generated_duration -v
python3 scripts/nightly_runner.py --tests tts_kokoro_generated_duration --json /path/to/duration-nightly.json

python3 version/v8/tts/build_kokoro_albert_circuit.py --check
python3 version/v8/tts/build_kokoro_encoder_circuit.py --check
python3 -m unittest tests.test_v8_kokoro_generated_encoder tests.test_v8_kokoro_generated_albert_layer -v

PYTHONPATH="$CKE_QWEN3_TTS_REFERENCE_ROOT" python \
  version/v8/tts/evaluate_qwen3_tts_accessibility_reference.py \
  --model-dir "$CKE_QWEN3_TTS_MODEL_DIR" \
  --case plain_update --case literal_path_signed \
  --policy sampled --max-new-tokens 320 --require-eos \
  --output-dir /tmp/cke-qwen3-accessibility-sampled

python version/v8/tts/qwen3_tts_pinned_session.py \
  --model-dir /path/to/85e237c12c027371202489a0ec509ded67b5e4b5 \
  --text 'Hello, this is CKE.' --output /tmp/qwen3-cke.wav --repeat 2

python version/v8/tts/qwen3_tts_pinned_session.py \
  --model-dir /path/to/85e237c12c027371202489a0ec509ded67b5e4b5 \
  --runtime-prompts --text 'Yes, I can hear you now.' \
  --output /tmp/qwen3-eight.wav

TMPDIR=/path/to/external/temp \
CKE_KOKORO_LAYER_EVIDENCE_DIR=/path/to/first-layer-evidence \
  python3 -m unittest tests.test_v8_kokoro_generated_albert_layer
python3 -m unittest tests.test_v8_normalization_checked_oracle \
  tests.test_v8_normalization_checked_generated

python3 version/v8/tts/build_kokoro_encoder_circuit.py --check
CKE_KOKORO_BUMP_DIR=/path/to/kokoro-bump \
CKE_KOKORO_ENCODER_EVIDENCE_DIR=/path/to/encoder-evidence \
  python3 tests/test_v8_kokoro_generated_encoder.py
python3 scripts/nightly_runner.py --tests tts_kokoro_generated_encoder \
  --json /path/to/encoder-nightly.json

CKE_KOKORO_MODEL_DIR=/path/to/pinned/kokoro \
  python3 tests/test_v8_kokoro_bump_export_live.py
python3 version/v8/tts/export_kokoro_bump.py \
  --model-dir /path/to/pinned/kokoro \
  --output-dir /path/to/kokoro-bump

python3 -m unittest \
  tests.test_v8_kokoro_shape_bounds \
  tests.test_v8_audio_duration_expand_oracle.AudioDurationExpandOracleTest.test_committed_torch_fixture \
  tests.test_v8_audio_istft_oracle.AudioIstftOracleTest.test_committed_torch_fixture \
  tests.test_v8_audio_istft_oracle.AudioIstftSafetyTest

python3 -m unittest tests.test_v8_audio_duration_expand_oracle tests.test_v8_audio_istft_oracle

python version/v8/tts/reference/capture_kokoro_v1.py \
  --model-dir /path/to/Kokoro-82M-snapshot \
  --output-dir /tmp/cke-kokoro-v1-af-heart-reference