Add MOSS-TTS-Local Phase 5: voice cloning + session/CLI wiring

Wire the MOSS-TTS-Local session end to end: the text processor builds the
generation prefix, the generator emits RVQ codes, and the codec decoder renders
48 kHz stereo. Add voice cloning via the MOSS-Audio-Tokenizer-v2 encoder
(audio -> RLFQ codes), the structural mirror of the decoder; extract the shared
ProjectedTransformer machinery into codec_transformer.h so the encoder and
decoder share one implementation. The processor's clone prefix embeds the
reference speaker's codes under "- Reference(s):"; the session resamples and
loudness-normalizes a --voice-ref clip, encodes it, and seeds generation.

Parity-verified against the transformers reference: generation loop 96/96 codes
over 8 frames, encoder 300/300 codes, clone input_ids 100x13 exact, decoder
cosine 1.0.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: justinjohn0306

CMakeLists.txt

@@ -209,11 +209,13 @@ add_library(engine_runtime STATIC
     src/models/moss_tts_local/assets.cpp
     src/models/moss_tts_local/backbone.cpp
     src/models/moss_tts_local/codec_decoder.cpp
+    src/models/moss_tts_local/codec_encoder.cpp
     src/models/moss_tts_local/codec_quantizer.cpp
     src/models/moss_tts_local/depth_transformer.cpp
     src/models/moss_tts_local/generator.cpp
     src/models/moss_tts_local/loader.cpp
     src/models/moss_tts_local/processor.cpp
+    src/models/moss_tts_local/session.cpp
     src/models/voxcpm2/assets.cpp
     src/models/voxcpm2/audiovae.cpp
     src/models/voxcpm2/generator.cpp
@@ -468,6 +470,15 @@ if (ENGINE_ENABLE_OPENMP)
     target_link_libraries(codec_decode_parity PRIVATE OpenMP::OpenMP_CXX)
 endif()
 
+add_executable(codec_encode_parity
+    tests/moss_tts_local/codec_encode_parity.cpp
+)
+
+target_link_libraries(codec_encode_parity PRIVATE engine_runtime ggml)
+if (ENGINE_ENABLE_OPENMP)
+    target_link_libraries(codec_encode_parity PRIVATE OpenMP::OpenMP_CXX)
+endif()
+
 if (ENGINE_BUILD_WARMBENCH)
     function(add_engine_warmbench target_name source_file)
         add_executable(${target_name}

include/engine/models/moss_tts_local/assets.h

@@ -75,4 +75,9 @@ MossTTSLocalAssetPaths resolve_moss_tts_local_assets(const std::filesystem::path
 MossTTSLocalConfig load_moss_tts_local_config(const std::filesystem::path & model_path);
 std::shared_ptr<const MossTTSLocalAssets> load_moss_tts_local_assets(const std::filesystem::path & model_path);
 
+// Locates the MOSS-Audio-Tokenizer-v2 codec weights: prefers a local audio_tokenizer/
+// directory next to the model, otherwise resolves the Hugging Face hub cache snapshot for
+// the repo id recorded in config (audio_tokenizer_name_or_path).
+std::filesystem::path resolve_moss_codec_dir(const MossTTSLocalAssets & assets);
+
 }  // namespace engine::models::moss_tts_local

include/engine/models/moss_tts_local/codec_encoder.h

@@ -0,0 +1,40 @@
+#pragma once
+
+#include "engine/framework/core/execution_context.h"
+
+#include <cstdint>
+#include <filesystem>
+#include <memory>
+#include <vector>
+
+namespace engine::models::moss_tts_local {
+
+// MOSS-Audio-Tokenizer-v2 encoder: turns a reference waveform into RLFQ codes
+// for zero-shot voice cloning. It is the structural mirror of MossCodecDecoder --
+// stereo is interleaved into one stream, patched down and run through a stack of
+// causal Transformer blocks (interleaved RoPE, LayerScale, GELU MLP), then the
+// RLFQ quantizer selects the nearest codes. Produces the same [num_quantizers,
+// frames] code matrix the generator consumes.
+class MossCodecEncoder {
+public:
+    MossCodecEncoder(
+        const std::filesystem::path & codec_dir,
+        core::ExecutionContext & execution_context,
+        int64_t num_quantizers,
+        size_t weight_context_bytes,
+        size_t graph_arena_bytes);
+    ~MossCodecEncoder();
+
+    MossCodecEncoder(const MossCodecEncoder &) = delete;
+    MossCodecEncoder & operator=(const MossCodecEncoder &) = delete;
+
+    // Encodes a waveform given as {left, right} channels (each with the same
+    // per-channel sample count, 48 kHz) into [num_quantizers][frames] codes.
+    std::vector<std::vector<int32_t>> encode(const std::vector<std::vector<float>> & channels) const;
+
+private:
+    struct Impl;
+    std::unique_ptr<Impl> impl_;
+};
+
+}  // namespace engine::models::moss_tts_local

include/engine/models/moss_tts_local/codec_quantizer.h

@@ -22,11 +22,21 @@ class MossCodecDequantizer {
 
     std::vector<float> decode(const std::vector<std::vector<int32_t>> & codes) const;
 
+    // Quantizes the encoder latent into codes: the inverse of decode(). `hidden`
+    // is [frames, code_dim] feature-last (row-major: frame * code_dim + channel),
+    // matching the codec encoder's output. Mirrors the RLFQ forward pass
+    // (input_proj -> per-quantizer in_proj -> L2-normalized nearest code ->
+    // residual subtraction) and returns the [num_quantizers][frames] code matrix.
+    std::vector<std::vector<int32_t>> encode(const std::vector<float> & hidden, int64_t frames) const;
+
 private:
     struct Codebook {
-        std::vector<float> table;       // [codebook_size, codebook_dim] row-major
-        std::vector<float> out_weight;  // [rvq_dim, codebook_dim] row-major
-        std::vector<float> out_bias;    // [rvq_dim]
+        std::vector<float> table;             // [codebook_size, codebook_dim] row-major
+        std::vector<float> table_normalized;  // [codebook_size, codebook_dim], L2-normalized rows (encode)
+        std::vector<float> out_weight;        // [rvq_dim, codebook_dim] row-major
+        std::vector<float> out_bias;          // [rvq_dim]
+        std::vector<float> in_weight;         // [codebook_dim, rvq_dim] row-major (encode)
+        std::vector<float> in_bias;           // [codebook_dim] (encode)
     };
 
     int64_t codebook_size_ = 0;
@@ -37,6 +47,8 @@ class MossCodecDequantizer {
     std::vector<Codebook> codebooks_;
     std::vector<float> output_weight_;  // [code_dim, rvq_dim] row-major
     std::vector<float> output_bias_;    // [code_dim]
+    std::vector<float> input_weight_;   // [rvq_dim, code_dim] row-major (encode)
+    std::vector<float> input_bias_;     // [rvq_dim] (encode)
 };
 
 }  // namespace engine::models::moss_tts_local